Put tests to test folder, remove unrequired files, fix permissions

Merge remote-tracking branches 'origin/svn-branches/RC_1_31_0', 'origin/svn-branches/RC_1_32_0', 'origin/svn-branches/RC_1_33_0', 'origin/svn-branches/SPIRIT_1_6', 'origin/svn-branches/SPIRIT_MINIBOOST', 'origin/svn-branches/bcbboost', 'origin/svn-branches/bitten', 'origin/svn-branches/compiler_supported_error_messages', 'origin/svn-branches/cpp0x', 'origin/svn-branches/doc', 'origin/svn-branches/maintenance/1_41', 'origin/svn-branches/maintenance/1_50_0', 'origin/svn-branches/maintenance/1_54_0', 'origin/svn-branches/maintenance/1_55_0', 'origin/svn-branches/mpl_v2_2', 'origin/svn-branches/multi_array', 'origin/svn-branches/pdimov_pre_136', 'origin/svn-branches/phoenix_v3', 'origin/svn-branches/proto/v3', 'origin/svn-branches/proto/v4', 'origin/svn-branches/proto/v4.bak', 'origin/svn-branches/python-v2-dev', 'origin/svn-branches/quickbook-dev', 'origin/svn-branches/quickbook-filenames', 'origin/svn-branches/regex-sub', 'origin/svn-branches/serialization_next_release', 'origin/svn-branches/split-config', 'origin/svn-branches/sredl_2009_05_proptree_update', 'origin/svn-branches/system', 'origin/svn-branches/thread_rewrite', 'origin/svn-branches/units/autoprefix', 'origin/svn-branches/unlabeled-1.1.2', 'origin/svn-tags/RC_1_34_0_freeze', 'origin/svn-tags/SPIRIT_1_6_4_MINIBOOST', 'origin/svn-tags/SPIRIT_1_8_5_MINIBOOST', 'origin/svn-tags/SPIRIT_MINIBOOST_1_34_0', 'origin/svn-tags/conversion-merge-1', 'origin/svn-tags/merged_to_RC_', 'origin/svn-tags/merged_to_RC_1_30_0', 'origin/svn-tags/merged_to_RC_1_31_0', 'origin/svn-tags/merged_to_RC_1_33_0' and 'origin/svn-tags/merged_to_RC_1_34_0' into develop
qMerge remote-tracking branches 'origin/svn-branches/modular-build', 'origin/svn-branches/xpressive/nested_dynamic_regex', 'origin/svn-tags/boost_python_llnl_', 'origin/svn-tags/minmax', 'origin/svn-tags/start/Version_1_18_3' and 'origin/svn-tags/tools/jam/Perforce_Jam_2_4_merge_1' into develop
2026-08-04 20:44:11 +02:00 · 2013-12-04 20:11:33 +04:00 · 2013-12-04 15:40:59 +04:00 · 2013-12-04 15:25:43 +04:00 · 2013-12-04 15:19:24 +04:00 · 2013-12-04 13:33:54 +04:00
46 changed files with 9100 additions and 1284 deletions
@@ -1,59 +1,97 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
 <html>
+  <head>
+    <meta name="generator" content=
+    "Microsoft FrontPage 5.0">
+    <meta http-equiv="Content-Type" content=
+    "text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">

-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Header boost/cast.hpp Documentation</title>
-</head>
+    <title>Header boost/cast.hpp Documentation</title>
+    <style>
+       .copyright
+        {
+            color: #666666;
+            font-size: small;
+        }
+    </style>
+  </head>

-<body bgcolor="#FFFFFF" text="#000000">
+  <body bgcolor="#FFFFFF" text="#000000">
+    <h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
+    "middle" width="277" height="86">Header <a href=
+    "../../boost/cast.hpp">boost/cast.hpp</a></h1>

-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
-<a href="../../boost/cast.hpp">boost/cast.hpp</a></h1>
-<h2><a name="Cast Functions">Cast Functions</a></h2>
-<p>The <code>header <a href="../../boost/cast.hpp">boost/cast.hpp</a></code>
-provides <a href="#Polymorphic_cast"><b>polymorphic_cast</b></a>, <a href="#Polymorphic_cast"><b>polymorphic_downcast</b></a>,
-and <a href="#numeric_cast"><b>numeric_cast</b></a> function templates designed
-to complement the C++ built-in casts.</p>
-<p>The program&nbsp;<a href="cast_test.cpp">cast_test.cpp</a> can be used to
-verify these function templates work as expected.</p>
-<h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
-<p>Pointers to polymorphic objects (objects of classes which define at least one
-virtual function) are sometimes downcast or crosscast.&nbsp; Downcasting means
-casting from a base class to a derived class.&nbsp; Crosscasting means casting
-across an inheritance hierarchy diagram, such as from one base to the other in a
-<b>Y</b> diagram hierarchy.</p>
-<p>Such casts can be done with old-style casts, but this approach is never to be
-recommended.&nbsp; Old-style casts are sorely lacking in type safety, suffer
-poor readability, and are difficult to locate with search tools.</p>
-<p>The C++ built-in <b>static_cast</b> can be used for efficiently downcasting
-pointers to polymorphic objects, but provides no error detection for the case
-where the pointer being cast actually points to the wrong derived class. The <b>polymorphic_downcast</b>
-template retains the efficiency of <b>static_cast</b> for non-debug
-compilations, but for debug compilations adds safety via an assert() that a <b>dynamic_cast</b>
-succeeds.&nbsp;<b>&nbsp;</b></p>
-<p>The C++ built-in <b>dynamic_cast</b> can be used for downcasts and crosscasts
-of pointers to polymorphic objects, but error notification in the form of a
-returned value of 0 is inconvenient to test, or worse yet, easy to forget to
-test.&nbsp; The <b>polymorphic_cast</b> template performs a <b>dynamic_cast</b>,
-and throws an exception if the <b>dynamic_cast</b> returns 0.</p>
-<p>A <b>polymorphic_downcast</b> is preferred when debug-mode tests will cover
-100% of the object types possibly cast and when non-debug-mode efficiency is an
-issue. If these two conditions are not present, <b>polymorphic_cast</b> is
-preferred.&nbsp; It must also be used for crosscasts.&nbsp; It does an assert(
-dynamic_cast&lt;Derived&gt;(x) == x ) where x is the base pointer, ensuring that
-not only is a non-zero pointer returned, but also that it correct in the
-presence of multiple inheritance.<b> Warning:</b>: Because <b>polymorphic_downcast</b>
-uses assert(), it violates the one definition rule (ODR) if NDEBUG is inconsistently
-defined across translation units.&nbsp; [See ISO Std 3.2]</p>
-<p>The C++ built-in <b>dynamic_cast</b> must be used to cast references rather
-than pointers.&nbsp; It is also the only cast that can be used to check whether
-a given interface is supported; in that case a return of 0 isn't an error
-condition.</p>
-<h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
-<blockquote>
-  <pre>namespace boost {
+    <h2><a name="Cast Functions">Cast Functions</a></h2>
+
+    <p>The header <a href="../../boost/cast.hpp">boost/cast.hpp</a> provides <code>
+    <a href="#Polymorphic_cast">polymorphic_cast</a> and</code> <a href=
+    "#Polymorphic_cast"><code>polymorphic_downcast</code></a> function templates designed to
+    complement the C++ built-in casts.</p>
+
+    <p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
+    verify these function templates work as expected.</p>
+
+    <h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
+
+    <p>Pointers to polymorphic objects (objects of classes which define at
+    least one virtual function) are sometimes downcast or crosscast.
+    Downcasting means casting from a base class to a derived class.
+    Crosscasting means casting across an inheritance hierarchy diagram, such
+    as from one base to the other in a <code>Y</code> diagram hierarchy.</p>
+
+    <p>Such casts can be done with old-style casts, but this approach is
+    never to be recommended. Old-style casts are sorely lacking in type
+    safety, suffer poor readability, and are difficult to locate with search
+    tools.</p>
+
+    <p>The C++ built-in <code>static_cast</code> can be used for efficiently
+    downcasting pointers to polymorphic objects, but provides no error
+    detection for the case where the pointer being cast actually points to
+    the wrong derived class. The <code>polymorphic_downcast</code> template retains
+    the efficiency of <code>static_cast</code> for non-debug compilations, but for
+    debug compilations adds safety via an assert() that a <code>dynamic_cast</code>
+    succeeds.</p>
+
+    <p>The C++ built-in <code>dynamic_cast</code> can be used for downcasts and
+    crosscasts of pointers to polymorphic objects, but error notification in
+    the form of a returned value of 0 is inconvenient to test, or worse yet,
+    easy to forget to test. The throwing form of <code>dynamic_cast</code>, which
+    works on references, can be used on pointers through the ugly expression
+    &amp;<code>dynamic_cast&lt;T&amp;&gt;(*p)</code>, which causes undefined
+    behavior if <code>p</code> is <code>0</code>. The <code>polymorphic_cast</code>
+    template performs a <code>dynamic_cast</code> on a pointer, and throws an
+    exception if the <code>dynamic_cast</code> returns 0.</p>
+
+    <p>A <code>polymorphic_downcast</code> should be used for
+    downcasts that you are certain should succeed.  Error checking is
+    only performed in translation units where <code>NDEBUG</code> is
+    not defined, via
+<pre>  assert( dynamic_cast&lt;Derived&gt;(x) == x )
+</pre> where <code>x</code> is the source pointer.  This approach
+    ensures that not only is a non-zero pointer returned, but also
+    that it is correct in the presence of multiple inheritance.
+    Attempts to crosscast using <code>polymorphic_downcast</code> will
+    fail to compile.
+    <b>Warning:</b> Because <code>polymorphic_downcast</code> uses assert(), it
+    violates the One Definition Rule (ODR) if NDEBUG is inconsistently
+    defined across translation units. [See ISO Std 3.2]
+</p><p>
+    For crosscasts, or when the success of a cast can only be known at
+    runtime, or when efficiency is not important,
+    <code>polymorphic_cast</code> is preferred. </p>
+
+    <p>The C++ built-in <code>dynamic_cast</code> must be used to cast references
+    rather than pointers. It is also the only cast that can be used to check
+    whether a given interface is supported; in that case a return of 0 isn't
+    an error condition.</p>
+
+    <h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
+
+    <blockquote>
+<pre>namespace boost {

 template &lt;class Derived, class Base&gt;
 inline Derived polymorphic_cast(Base* x);
@@ -65,11 +103,14 @@ inline Derived polymorphic_downcast(Base* x);
 // Effects: assert( dynamic_cast&lt;Derived&gt;(x) == x );
 // Returns: static_cast&lt;Derived&gt;(x)

-}</pre>
-</blockquote>
-<h3>polymorphic_downcast example</h3>
-<blockquote>
-  <pre>#include &lt;boost/cast.hpp&gt;
+}
+</pre>
+    </blockquote>
+
+    <h3>polymorphic_downcast example</h3>
+
+    <blockquote>
+<pre>#include &lt;boost/cast.hpp&gt;
 ...
 class Fruit { public: virtual ~Fruit(){}; ... };
 class Banana : public Fruit { ... };
@@ -77,69 +118,29 @@ class Banana : public Fruit { ... };
 void f( Fruit * fruit ) {
 // ... logic which leads us to believe it is a Banana
  Banana * banana = boost::polymorphic_downcast&lt;Banana*&gt;(fruit);
-  ...</pre>
-</blockquote>
-<h3><a name="numeric_cast">numeric_cast</a></h3>
-<p>A <b>static_cast</b> or implicit conversion will not
-detect failure to preserve range for numeric casts. The <b>numeric_cast</b> function
-templates are similar to <b>static_cast</b> and certain (dubious)
-implicit conversions in this respect, except that they detect loss of numeric
-range. An exception is thrown when a runtime value-preservation check fails.</p>
-<p>The requirements on the argument and result types are:</p>
-<blockquote>
-  <ul>
-    <li>Both argument and result types are CopyConstructible [ISO Std 20.1.3].</li>
-    <li>Both argument and result types are Numeric, defined by <code>std::numeric_limits&lt;&gt;::is_specialized</code>
-      being true.</li>
-    <li>The argument can be converted to the result type using <b>static_cast</b>.</li>
-  </ul>
-</blockquote>
-<h3>numeric_cast synopsis</h3>
-<blockquote>
-  <pre>namespace boost {
+  ...
+</pre>
+    </blockquote>

-class bad_numeric_cast : public std::bad_cast {...};
+    <h3>History</h3>

-template&lt;typename Target, typename Source&gt;
-  inline Target numeric_cast(Source arg);
-    // Throws:  bad_numeric_cast unless, in converting arg from Source to Target,
-    //          there is no loss of negative range, and no underflow, and no
-    //          overflow, as determined by std::numeric_limits
-    // Returns: static_cast&lt;Target&gt;(arg)
+    <p><code>polymorphic_cast</code> was suggested by Bjarne Stroustrup in "The C++
+    Programming Language".<br>
+     <code>polymorphic_downcast</code> was contributed by <a href=
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>.<code><br>
+     An old
+     numeric_cast</code> that was contributed by <a href=
+    "http://www.boost.org/people/kevlin_henney.htm">Kevlin Henney</a> is now superseeded by the <a href="../numeric/conversion/doc/html/index.html">Boost Numeric Conversion Library</a></p>
+    <hr>

-}</pre>
-</blockquote>
-<h3>numeric_cast example</h3>
-<blockquote>
-  <pre>#include &lt;boost/cast.hpp&gt;
-using namespace boost::cast;
-
-void ariane(double vx)
-{
-    ...
-    unsigned short dx = numeric_cast&lt;unsigned short&gt;(vx);
-    ...
-}</pre>
-</blockquote>
-<h3>numeric_cast rationale</h3>
-<p>The form of the throws condition is specified so that != is not a required
-operation.</p>
-<h3>History</h3>
-<p><b>polymorphic_cast</b> was suggested by Bjarne Stroustrup in &quot;The C++
-Programming Language&quot;.<br>
-<b>polymorphic_downcast</b> was contributed by <a href="../../people/dave_abrahams.htm">Dave
-Abrahams</a>.<b><br>
-numeric_cast</b> was contributed by <a href="../../people/kevlin_henney.htm">Kevlin
-Henney</a>.</p>
-<hr>
-<p>Revised&nbsp; <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
-->06 January, 2001<!--webbot bot="Timestamp" endspan i-checksum="38320"
--></p>
-<p>© Copyright boost.org 1999. Permission to copy, use, modify, sell and
-distribute this document is granted provided this copyright notice appears in
-all copies. This document is provided &quot;as is&quot; without express or
-implied warranty, and with no claim as to its suitability for any purpose.</p>
-
-</body>
+    <p>Revised
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
+                    -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348"
+                    --></p>

+    <p class="copyright">&copy; Copyright boost.org 1999. 
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
+    </p>
+  </body>
 </html>
@@ -1,153 +0,0 @@
-//  boost utility cast test program  -----------------------------------------//
-
-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies. This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//   20 Jan 01  removed use of <limits> for portability to raw GCC (David Abrahams)
-//   28 Jun 00  implicit_cast removed (Beman Dawes)
-//   30 Aug 99  value_cast replaced by numeric_cast
-//    3 Aug 99  Initial Version
-
-#include <iostream>
-#include <climits>
-#include <boost/cast.hpp>
-
-#  if SCHAR_MAX == LONG_MAX
-#      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
-#  endif 
-
-using namespace boost;
-using std::cout;
-
-namespace
-{
-    struct Base
-    { 
-        virtual char kind() { return 'B'; }
-    };
-    
-    struct Base2
-    { 
-        virtual char kind2() { return '2'; }
-    };
-    
-    struct Derived : public Base, Base2
-    {
-        virtual char kind() { return 'D'; }
-    }; 
-}   
-
-
-int main( int argc, char * argv[] )
-{
-    cout << "Usage: test_casts [n], where n omitted or is:\n"
-            "  1 = execute #1 assert failure (#ifndef NDEBUG)\n"
-            "  2 = execute #2 assert failure (#ifndef NDEBUG)\n"
-            "Example: test_casts 2\n\n";
-
-#   ifdef NDEBUG
-        cout << "NDEBUG is defined\n";
-#   else
-        cout << "NDEBUG is not defined\n";
-#   endif
-
-    cout << "\nBeginning tests...\n";        
-
-//  test polymorphic_cast  ---------------------------------------------------//
-    
-    //  tests which should succeed
-    Base *    base = new Derived;
-    Base2 *   base2 = 0;
-    Derived * derived = 0;
-    derived = polymorphic_downcast<Derived*>( base );  // downcast
-    assert( derived->kind() == 'D' );
-
-    derived = 0;
-    derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
-    assert( derived->kind() == 'D' );
-
-    base2 = polymorphic_cast<Base2*>( base ); // crosscast
-    assert( base2->kind2() == '2' );
-
-     //  tests which should result in errors being detected
-    int err_count = 0;
-    base = new Base;
-
-    if ( argc > 1 && *argv[1] == '1' )
-        { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
-
-    bool caught_exception = false;
-    try { derived = polymorphic_cast<Derived*>( base ); }
-    catch (std::bad_cast)
-        { cout<<"caught bad_cast\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-    //  the following is just so generated code can be inspected
-    if ( derived->kind() == 'B' ) ++err_count;
-
-//  test implicit_cast and numeric_cast  -------------------------------------//
-    
-    //  tests which should succeed
-    long small_value = 1;
-    long small_negative_value = -1;
-    long large_value = LONG_MAX;
-    long large_negative_value = LONG_MIN;
-    signed char c = 0;
-
-    c = large_value;  // see if compiler generates warning
-
-    c = numeric_cast<signed char>( small_value );
-    assert( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_value );
-    assert( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_negative_value );
-    assert( c == -1 );
-
-    // These tests courtesy of Joe R NWP Swatosh<joe.r.swatosh@usace.army.mil>
-    assert( 0.0f == numeric_cast<float>( 0.0 ) );
-    assert( 0.0 == numeric_cast<double>( 0.0 ) );
-    
-    //  tests which should result in errors being detected
-
-    caught_exception = false;
-    try { c = numeric_cast<signed char>( large_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { c = numeric_cast<signed char>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    unsigned long ul;
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { numeric_cast<int>( DBL_MAX ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    cout << err_count << " errors detected\nTest "
-         << (err_count==0 ? "passed\n" : "failed\n");
-    return err_count;
-}   // main
@@ -0,0 +1,16 @@
+# Copyright Antony Polukhin 2011. 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)
+
+using quickbook ;
+import boostbook : boostbook ;
+
+xml lexical_cast : lexical_cast.qbk ;
+boostbook standalone
+    :
+    lexical_cast
+    :
+        <xsl:param>boost.root=../../../..
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+    ;
+
@@ -0,0 +1,941 @@
+[library Boost.Lexical_Cast
+    [quickbook 1.5]
+    [version 1.0]
+    [copyright 2000-2005 Kevlin Henney]
+    [copyright 2006-2010 Alexander Nasonov]
+    [copyright 2011-2013 Antony Polukhin]
+    [category String and text processing]
+    [category Miscellaneous]
+    [license
+        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])
+    ]
+]
+
+[def __numericcast__  [@boost:libs/numeric/conversion/doc/html/boost_numericconversion/improved_numeric_cast__.html `boost::numeric_cast`]]
+[def __proposallong__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973 by Kevlin Henney and Beman Dawes]]
+[def __proposalshort__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973]]
+
+[section Motivation]
+Sometimes a value must be converted to a literal text form, such as an [c++] `int` represented as a `std::string`, or vice-versa, when a `std::string` is interpreted as an `int`. Such examples are common when converting between data types internal to a program and representation external to a program, such as windows and configuration files.
+
+The standard C and C++ libraries offer a number of facilities for performing such conversions. However, they vary with their ease of use, extensibility, and safety.
+
+For instance, there are a number of limitations with the family of standard C functions typified by `atoi`:
+
+* Conversion is supported in one direction only: from text to internal data type. Converting the other way using the C library requires either the inconvenience and compromised safety of the `sprintf` function, or the loss of portability associated with non-standard functions such as `itoa`.
+* The range of types supported is only a subset of the built-in numeric types, namely `int`, `long`, and `double`.
+* The range of types cannot be extended in a uniform manner. For instance, conversion from string representation to complex or rational.
+
+The standard C functions typified by `strtol` have the same basic limitations, but offer finer control over the conversion process. However, for the common case such control is often either not required or not used. The `scanf` family of functions offer even greater control, but also lack safety and ease of use.
+
+The standard C++ library offers `stringstream` for the kind of in-core formatting being discussed. It offers a great deal of control over the formatting and conversion of I/O to and from arbitrary types through text. However, for simple conversions direct use of `stringstream` can be either clumsy (with the introduction of extra local variables and the loss of infix-expression convenience) or obscure (where `stringstream` objects are created as temporary objects in an expression). Facets provide a comprehensive concept and facility for controlling textual representation, but their perceived complexity and high entry level requires an extreme degree of involvement for simple conversions, and excludes all but a few programmers.
+
+The `lexical_cast` function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text. The simplification it offers is in expression-level convenience for such conversions. For more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of `lexical_cast`, the conventional `std::stringstream` approach is recommended. Where the conversions are numeric to numeric, __numericcast__ may offer more reasonable behavior than `lexical_cast`.
+
+For a good discussion of the options and issues involved in string-based formatting, including comparison of `stringstream`, `lexical_cast`, and others, see Herb Sutter's article, [@http://www.gotw.ca/publications/mill19.htm The String Formatters of Manor Farm]. Also, take a look at the [link boost_lexical_cast.performance Performance] section.
+[endsect]
+
+[section Examples]
+
+[import ../example/args_to_numbers.cpp]
+
+[section Strings to numbers conversion] [lexical_cast_args_example] [endsect]
+
+[import ../example/small_examples.cpp]
+[section Numbers to strings conversion] [lexical_cast_log_errno] [endsect]
+[section Converting to string without dynamic memory allocation] [lexical_cast_fixed_buffer] [endsect]
+[section Converting part of the string] [lexical_cast_substring_conversion] [endsect]
+
+[import ../example/generic_stringize.cpp]
+[section Generic programming (Boost.Fusion)] [lexical_cast_stringize] [endsect]
+
+[import ../example/variant_to_long_double.cpp]
+[section Generic programming (Boost.Variant)] [lexical_cast_variant_to_long_double] [endsect]
+
+[endsect]
+
+[section Synopsis]
+Library features defined in [@boost:boost/lexical_cast.hpp boost/lexical_cast.hpp]:
+``
+    namespace boost
+    {
+        class bad_lexical_cast;
+        
+        template<typename Target, typename Source>
+          Target lexical_cast(const Source& arg);
+
+        template <typename Target>
+          Target lexical_cast(const AnyCharacterType* chars, std::size_t count);
+    }
+``
+
+[section lexical_cast]
+``
+    template<typename Target, typename Source>
+      Target lexical_cast(const Source& arg);
+``
+Returns the result of streaming arg into a standard library string-based stream and then out as a Target object. Where Target is either `std::string` or `std::wstring`, stream extraction takes the whole content of the string, including spaces, rather than relying on the default `operator>>` behavior. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown.
+
+``
+    template <typename Target>
+      Target lexical_cast(const AnyCharacterType* chars, std::size_t count);
+``
+Takes an array of `count` characters as input parameter and streams them out as a Target object. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown. This call may be useful for processing nonzero terminated array of characters or processing just some part of character array.
+
+The requirements on the argument and result types for both functions are:
+
+* Source is OutputStreamable, meaning that an `operator<<` is defined that takes a `std::ostream` or `std::wostream` object on the left hand side and an instance of the argument type on the right.
+* Target is InputStreamable, meaning that an `operator>>` is defined that takes a `std::istream` or `std::wistream` object on the left hand side and an instance of the result type on the right.
+* Target is CopyConstructible [20.1.3].
+* Target is DefaultConstructible, meaning that it is possible to default-initialize an object of that type [8.5, 20.1.4].
+
+The character type of the underlying stream is assumed to be `char` unless either the `Source` or the `Target` requires wide-character streaming, in which case the underlying stream uses `wchar_t`. Following types also can use `char16_t` or `char32_t` for wide-character streaming:
+
+* Single character: `char16_t`, `char32_t`
+* Arrays of characters: `char16_t *`, `char32_t *`, `const char16_t *`, `const char32_t *`
+* Strings: `std::basic_string`, `boost::containers::basic_string`
+* `boost::iterator_range<WideCharPtr>`, where `WideCharPtr` is a pointer to wide-character or pointer to const wide-character
+* `boost::array<CharT, N>` and `std::array<CharT, N>`, `boost::array<const CharT, N>` and `std::array<const CharT, N>` 
+
+[important Many compilers and runtime libraries fail to make conversions using new Unicode characters. Make sure that the following code compiles and outputs nonzero values, before using new types:
+``
+    std::cout
+        << boost::lexical_cast<std::u32string>(1.0).size()
+        << "  "
+        << boost::lexical_cast<std::u16string>(1.0).size();
+``
+]
+
+Where a higher degree of control is required over conversions, `std::stringstream` and `std::wstringstream` offer a more appropriate path. Where non-stream-based conversions are required, `lexical_cast` is the wrong tool for the job and is not special-cased for such scenarios.
+[endsect]
+
+[section bad_lexical_cast]
+``
+    class bad_lexical_cast : public std::bad_cast
+    {
+    public:
+        ... // same member function interface as std::exception
+    };
+``
+Exception used to indicate runtime lexical_cast failure.
+[endsect]
+
+[endsect]
+
+[section Frequently Asked Questions]
+
+* [*Question:]    Why does `lexical_cast<int8_t>("127")` throw `bad_lexical_cast`?
+  * [*Answer:]      The type `int8_t` is a `typedef` to `char` or `signed char`. Lexical conversion to these types is simply reading a byte from source but since the source has more than one byte, the exception is thrown.
+Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
+call __numericcast__:
+`numeric_cast<int8_t>(lexical_cast<int>("127"));`
+
+[pre
+]
+
+* [*Question:]    Why does `lexical_cast<unsigned char>("127")` throw `bad_lexical_cast`?
+  * [*Answer:]      Lexical conversion to any char type is simply reading a byte from source. But since the source has more than one byte, the exception is thrown.
+Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
+call __numericcast__:
+`numeric_cast<unsigned char>(lexical_cast<int>("127"));`
+
+[pre
+]
+
+* [*Question:]    What does `lexical_cast<std::string>` of an `int8_t` or `uint8_t` not do what I expect?
+  * [*Answer:]      As above, note that int8_t and uint8_t are actually chars and are formatted as such. To avoid
+this, cast to an integer type first: `lexical_cast<std::string>(static_cast<int>(n));`
+
+[pre
+]
+
+* [*Question:]    The implementation always resets the `ios_base::skipws` flag of an underlying stream object.
+It breaks my `operator>>` that works only in presence of this flag. Can you remove code that resets the flag?
+  * [*Answer:]      May be in a future version. There is no requirement in
+__proposallong__ to reset the flag but
+remember that __proposalshort__ is not yet accepted by the committee. By the way, it's a great opportunity to
+make your `operator>>` more general.
+Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html `ios_state_saver`].
+
+[pre
+]
+
+* [*Question:]    Why `std::cout << boost::lexical_cast<unsigned int>("-1");` does not throw, but outputs 4294967295?
+  * [*Answer:]      `boost::lexical_cast` has the behavior of `std::stringstream`, which uses `num_get` functions of
+`std::locale` to convert numbers. If we look at the Programming languages — C++, we'll see, that `num_get` uses
+the rules of `scanf` for conversions. And in the C99 standard for unsigned input value minus sign is optional, so
+if a negative number is read, no errors will arise and the result will be the two's complement.
+
+[pre
+]
+
+* [*Question:]    Why `boost::lexical_cast<int>(L'A');` outputs 65 and `boost::lexical_cast<wchar_t>(L"65");` does not throw?
+  * [*Answer:]      If you are using an old version of Visual Studio or compile code with /Zc:wchar_t- flag,
+`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.
+
+[pre
+]
+
+* [*Question:]    What is the fastest way to convert a non zero terminated string or a substring using `boost::lexical_cast`?
+  * [*Answer:]      Use `boost::iterator_range` for conversion or `lexical_cast` overload with two parameters. For example, if you whant to convert to `int` two characters from a string `str`, you shall write `lexical_cast<int>(make_iterator_range(str.data(), str.data() + 2));` or `lexical_cast<int>(str.data(), 2);`.
+
+[endsect]
+
+[section Changes]
+
+* [*boost 1.54.0 :]
+
+    * Fix some issues with `boost::int128_type` and `boost::uint128_type` conversions. Notify user at compile time 
+      if the `std::numeric_limits` are not specialized for 128bit types and `boost::lexical_cast` can not make conversions.
+
+* [*boost 1.54.0 :]
+
+    * Added code to convert `boost::int128_type` and `boost::uint128_type` types (requires GCC 4.7 or higher).
+    * Conversions to pointers will now fail to compile, instead of throwing at runtime.
+    * Restored ability to get pointers to `lexical_cast` function (was broken in 1.53.0).
+
+* [*boost 1.53.0 :]
+
+    * Much better input and output streams detection for user defined types.
+
+* [*boost 1.52.0 :]
+
+    * Restored compilation on MSVC-2003 (was broken in 1.51.0).
+    * Added `lexical_cast(const CharType* chars, std::size_t count)` function overload.
+    
+* [*boost 1.51.0 :]
+
+    * Better performance, less memory usage for `boost::array<character_type, N>` and `std::array<character_type, N>` conversions.
+
+* [*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.
+    * Better performance, less memory usage and bugfixes for `boost::iterator_range<character_type*>` conversions.
+
+* [*boost 1.49.0 :]
+
+    * Restored work with typedefed wchar_t (compilation flag /Zc:wchar_t- for Visual Studio).
+    * Better performance and less memory usage for `boost::container::basic_string` conversions.
+
+* [*boost 1.48.0 :]
+
+    * Added code to work with Inf and NaN on any platform.
+    * Better performance and less memory usage for conversions to float type (and to double type, if `sizeof(double) < sizeof(long double)`).
+
+* [*boost 1.47.0 :]
+
+    * Optimizations for "C" and other locales without number grouping.
+    * Better performance and less memory usage for unsigned char and signed char conversions.
+    * Better performance and less memory usage for conversions to arithmetic types.
+    * Better performance and less memory usage for conversions from arithmetic type to arithmetic type.
+    * Directly construct Target from Source on some conversions (like conversions from string to string, from char array to string, from char to char and others).
+
+* [*boost 1.34.0 :]
+
+    * Better performance for many combinations of Source and Target types. For more details refer to Alexander Nasonovs article [@http://accu.org/index.php/journals/1375 Fine Tuning for lexical_cast, Overload #74, August 2006] [@http://www.accu.org/var/uploads/journals/overload74.pdf (PDF)].
+
+* [*boost 1.33.0 :]
+
+    * Call-by-const reference for the parameters. This requires partial specialization of class templates, so it doesn't work for MSVC 6, and it uses the original pass by value there.
+    * The MSVC 6 support is deprecated, and will be removed in a future Boost version.
+
+* [*Earlier :]
+
+    * The previous version of lexical_cast used the default stream precision for reading and writing floating-point numbers. For numerics that have a corresponding specialization of `std::numeric_limits`, the current version now chooses a precision to match.
+    * The previous version of lexical_cast did not support conversion to or from any wide-character-based types. For compilers with full language and library support for wide characters, `lexical_cast` now supports conversions from `wchar_t`, `wchar_t *`, and `std::wstring` and to `wchar_t` and `std::wstring`.
+    * The previous version of `lexical_cast` assumed that the conventional stream extractor operators were sufficient for reading values. However, string I/O is asymmetric, with the result that spaces play the role of I/O separators rather than string content. The current version fixes this error for `std::string` and, where supported, `std::wstring`: `lexical_cast<std::string>("Hello, World")` succeeds instead of failing with a `bad_lexical_cast` exception.
+    * The previous version of `lexical_cast` allowed unsafe and meaningless conversions to pointers. The current version now throws a `bad_lexical_cast` for conversions to pointers: `lexical_cast<char *>("Goodbye, World")` now throws an exception instead of causing undefined behavior.
+
+[endsect]
+
+[section Performance]
+
+In most cases `boost::lexical_cast` is faster than `scanf`, `printf`, `std::stringstream`. For more detailed info you can look at the tables below.
+
+[section Tests description]
+All the tests measure execution speed in milliseconds for 10000 iterations of the following code blocks:
+[table:legend Tests source code
+[[Test name] [Code]]
+[[lexical_cast]
+  [``
+            _out = boost::lexical_cast<OUTTYPE>(_in);
+  ``]
+  ]
+[[std::stringstream with construction]
+  [``
+            std::stringstream ss;
+            ss << _in;
+            if (ss.fail()) throw std::logic_error(descr);
+            ss >> _out;
+            if (ss.fail()) throw std::logic_error(descr);
+  ``]
+  ]
+[[std::stringstream without construction]
+  [``
+            ss << _in; // ss is an instance of std::stringstream
+            if (ss.fail()) throw std::logic_error(descr);
+            ss >> _out;
+            if (ss.fail()) throw std::logic_error(descr);
+            /* reseting std::stringstream to use it again */
+            ss.str(std::string());
+            ss.clear();
+  ``]
+  ]
+[[scanf/printf]
+  [``
+            typename OUTTYPE::value_type buffer[500];
+            sprintf( (char*)buffer, conv, _in);
+            _out = buffer;
+  ``]
+  ]
+]
+Fastest results are highlitened with "!!! *x* !!!".
+Do not use this results to compare compilers, because tests were taken on different hardware.
+
+[endsect]
+
+[/ BEGIN of section, generated by performance measuring program ]
+
+
+[section Clang version 3.0 (tags/RELEASE_30/final)]
+[table:id Performance Table ( Clang version 3.0 (tags/RELEASE_30/final))
+[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
+  [[ string->char ][ !!! *<1* !!! ][ 169 ][ 9 ][ 10 ]]
+  [[ string->signed char ][ !!! *<1* !!! ][ 108 ][ 8 ][ 10 ]]
+  [[ string->unsigned char ][ !!! *<1* !!! ][ 103 ][ 9 ][ 10 ]]
+  [[ string->int ][ !!! *6* !!! ][ 117 ][ 24 ][ 24 ]]
+  [[ string->short ][ !!! *7* !!! ][ 115 ][ 20 ][ 24 ]]
+  [[ string->long int ][ !!! *7* !!! ][ 115 ][ 19 ][ 22 ]]
+  [[ string->long long ][ !!! *8* !!! ][ 116 ][ 21 ][ 23 ]]
+  [[ string->unsigned int ][ !!! *6* !!! ][ 121 ][ 18 ][ 23 ]]
+  [[ string->unsigned short ][ !!! *6* !!! ][ 116 ][ 19 ][ 22 ]]
+  [[ string->unsigned long int ][ !!! *7* !!! ][ 117 ][ 23 ][ 21 ]]
+  [[ string->unsigned long long ][ !!! *8* !!! ][ 118 ][ 19 ][ 34 ]]
+  [[ string->float ][ !!! *13* !!! ][ 201 ][ 55 ][ 41 ]]
+  [[ string->double ][ !!! *14* !!! ][ 151 ][ 54 ][ 41 ]]
+  [[ string->long double ][ 195 ][ 231 ][ 67 ][ !!! *42* !!! ]]
+  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 121 ][ 18 ][ 12 ]]
+  [[ string->string ][ !!! *1* !!! ][ 124 ][ 27 ][ --- ]]
+  [[ string->container::string ][ !!! *3* !!! ][ 114 ][ 25 ][ --- ]]
+  [[ string->char ][ 7 ][ 111 ][ 25 ][ !!! *7* !!! ]]
+  [[ string->signed char ][ !!! *6* !!! ][ 112 ][ 30 ][ 26 ]]
+  [[ string->unsigned char ][ !!! *6* !!! ][ 113 ][ 25 ][ 24 ]]
+  [[ int->string ][ !!! *12* !!! ][ 126 ][ 36 ][ 21 ]]
+  [[ short->string ][ !!! *11* !!! ][ 135 ][ 30 ][ 21 ]]
+  [[ long int->string ][ !!! *11* !!! ][ 128 ][ 28 ][ 21 ]]
+  [[ long long->string ][ !!! *12* !!! ][ 126 ][ 32 ][ 24 ]]
+  [[ unsigned int->string ][ !!! *11* !!! ][ 131 ][ 36 ][ 22 ]]
+  [[ unsigned short->string ][ !!! *11* !!! ][ 130 ][ 28 ][ 22 ]]
+  [[ unsigned long int->string ][ !!! *11* !!! ][ 130 ][ 36 ][ 22 ]]
+  [[ unsigned long long->string ][ !!! *11* !!! ][ 127 ][ 43 ][ 25 ]]
+  [[ float->string ][ 53 ][ 190 ][ 83 ][ !!! *41* !!! ]]
+  [[ double->string ][ 59 ][ 197 ][ 82 ][ !!! *44* !!! ]]
+  [[ long double->string ][ 118 ][ 229 ][ 101 ][ !!! *44* !!! ]]
+  [[ char*->char ][ !!! *1* !!! ][ 105 ][ 9 ][ 9 ]]
+  [[ char*->signed char ][ !!! *1* !!! ][ 107 ][ 10 ][ 10 ]]
+  [[ char*->unsigned char ][ !!! *1* !!! ][ 106 ][ 9 ][ 11 ]]
+  [[ char*->int ][ !!! *7* !!! ][ 149 ][ 25 ][ 24 ]]
+  [[ char*->short ][ !!! *7* !!! ][ 118 ][ 20 ][ 22 ]]
+  [[ char*->long int ][ !!! *9* !!! ][ 117 ][ 20 ][ 28 ]]
+  [[ char*->long long ][ !!! *9* !!! ][ 128 ][ 23 ][ 29 ]]
+  [[ char*->unsigned int ][ !!! *7* !!! ][ 120 ][ 19 ][ 23 ]]
+  [[ char*->unsigned short ][ !!! *7* !!! ][ 125 ][ 20 ][ 22 ]]
+  [[ char*->unsigned long int ][ !!! *8* !!! ][ 125 ][ 21 ][ 24 ]]
+  [[ char*->unsigned long long ][ !!! *8* !!! ][ 130 ][ 19 ][ 22 ]]
+  [[ char*->float ][ !!! *14* !!! ][ 162 ][ 56 ][ 41 ]]
+  [[ char*->double ][ !!! *16* !!! ][ 151 ][ 54 ][ 39 ]]
+  [[ char*->long double ][ 111 ][ 176 ][ 58 ][ !!! *42* !!! ]]
+  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 116 ][ 20 ][ 17 ]]
+  [[ char*->string ][ !!! *8* !!! ][ 125 ][ 27 ][ --- ]]
+  [[ char*->container::string ][ !!! *2* !!! ][ 115 ][ 26 ][ --- ]]
+  [[ unsigned char*->char ][ !!! *1* !!! ][ 101 ][ 9 ][ 9 ]]
+  [[ unsigned char*->signed char ][ !!! *1* !!! ][ 104 ][ 9 ][ 11 ]]
+  [[ unsigned char*->unsigned char ][ !!! *1* !!! ][ 103 ][ 9 ][ 13 ]]
+  [[ unsigned char*->int ][ !!! *8* !!! ][ 116 ][ 20 ][ 24 ]]
+  [[ unsigned char*->short ][ !!! *7* !!! ][ 121 ][ 20 ][ 26 ]]
+  [[ unsigned char*->long int ][ !!! *8* !!! ][ 118 ][ 20 ][ 22 ]]
+  [[ unsigned char*->long long ][ !!! *8* !!! ][ 122 ][ 20 ][ 23 ]]
+  [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 119 ][ 22 ][ 23 ]]
+  [[ unsigned char*->unsigned short ][ !!! *7* !!! ][ 122 ][ 20 ][ 22 ]]
+  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 125 ][ 21 ][ 22 ]]
+  [[ unsigned char*->unsigned long long ][ !!! *8* !!! ][ 122 ][ 19 ][ 25 ]]
+  [[ unsigned char*->float ][ !!! *14* !!! ][ 162 ][ 62 ][ 37 ]]
+  [[ unsigned char*->double ][ !!! *15* !!! ][ 151 ][ 58 ][ 39 ]]
+  [[ unsigned char*->long double ][ 116 ][ 156 ][ 58 ][ !!! *42* !!! ]]
+  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 122 ][ 19 ][ 15 ]]
+  [[ unsigned char*->string ][ !!! *8* !!! ][ 124 ][ 27 ][ --- ]]
+  [[ unsigned char*->container::string ][ !!! *4* !!! ][ 119 ][ 25 ][ --- ]]
+  [[ signed char*->char ][ !!! *1* !!! ][ 107 ][ 9 ][ 9 ]]
+  [[ signed char*->signed char ][ !!! *1* !!! ][ 108 ][ 10 ][ 11 ]]
+  [[ signed char*->unsigned char ][ !!! *1* !!! ][ 106 ][ 9 ][ 11 ]]
+  [[ signed char*->int ][ !!! *7* !!! ][ 122 ][ 21 ][ 22 ]]
+  [[ signed char*->short ][ !!! *7* !!! ][ 126 ][ 20 ][ 22 ]]
+  [[ signed char*->long int ][ !!! *8* !!! ][ 119 ][ 20 ][ 23 ]]
+  [[ signed char*->long long ][ !!! *8* !!! ][ 119 ][ 21 ][ 26 ]]
+  [[ signed char*->unsigned int ][ !!! *6* !!! ][ 124 ][ 18 ][ 22 ]]
+  [[ signed char*->unsigned short ][ !!! *7* !!! ][ 124 ][ 21 ][ 23 ]]
+  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 121 ][ 24 ][ 23 ]]
+  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 122 ][ 20 ][ 22 ]]
+  [[ signed char*->float ][ !!! *14* !!! ][ 167 ][ 56 ][ 37 ]]
+  [[ signed char*->double ][ !!! *14* !!! ][ 162 ][ 53 ][ 40 ]]
+  [[ signed char*->long double ][ 110 ][ 152 ][ 56 ][ !!! *42* !!! ]]
+  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 117 ][ 19 ][ 12 ]]
+  [[ signed char*->string ][ !!! *8* !!! ][ 132 ][ 27 ][ --- ]]
+  [[ signed char*->container::string ][ !!! *4* !!! ][ 116 ][ 26 ][ --- ]]
+  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 112 ][ 14 ][ 9 ]]
+  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 107 ][ 13 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 145 ][ 15 ][ 10 ]]
+  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 119 ][ 22 ][ 23 ]]
+  [[ iterator_range<char*>->short ][ !!! *6* !!! ][ 115 ][ 22 ][ 23 ]]
+  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 115 ][ 25 ][ 22 ]]
+  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 117 ][ 21 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 118 ][ 22 ][ 22 ]]
+  [[ iterator_range<char*>->unsigned short ][ !!! *6* !!! ][ 117 ][ 24 ][ 22 ]]
+  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 124 ][ 25 ][ 22 ]]
+  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 119 ][ 22 ][ 22 ]]
+  [[ iterator_range<char*>->float ][ !!! *13* !!! ][ 159 ][ 42 ][ 41 ]]
+  [[ iterator_range<char*>->double ][ !!! *14* !!! ][ 152 ][ 40 ][ 40 ]]
+  [[ iterator_range<char*>->long double ][ 113 ][ 155 ][ 58 ][ !!! *54* !!! ]]
+  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 127 ][ 23 ][ 13 ]]
+  [[ iterator_range<char*>->string ][ !!! *7* !!! ][ 132 ][ 30 ][ --- ]]
+  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 122 ][ 24 ][ --- ]]
+  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 110 ][ 9 ][ 10 ]]
+  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 119 ][ 9 ][ 13 ]]
+  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 106 ][ 13 ][ 11 ]]
+  [[ array<char, 50>->int ][ !!! *6* !!! ][ 131 ][ 21 ][ 22 ]]
+  [[ array<char, 50>->short ][ !!! *7* !!! ][ 119 ][ 22 ][ 28 ]]
+  [[ array<char, 50>->long int ][ !!! *8* !!! ][ 133 ][ 21 ][ 26 ]]
+  [[ array<char, 50>->long long ][ !!! *8* !!! ][ 115 ][ 22 ][ 23 ]]
+  [[ array<char, 50>->unsigned int ][ !!! *6* !!! ][ 118 ][ 18 ][ 22 ]]
+  [[ array<char, 50>->unsigned short ][ !!! *7* !!! ][ 119 ][ 19 ][ 22 ]]
+  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 118 ][ 23 ][ 21 ]]
+  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 117 ][ 20 ][ 22 ]]
+  [[ array<char, 50>->float ][ !!! *15* !!! ][ 156 ][ 53 ][ 36 ]]
+  [[ array<char, 50>->double ][ !!! *15* !!! ][ 148 ][ 55 ][ 39 ]]
+  [[ array<char, 50>->long double ][ 110 ][ 150 ][ 56 ][ !!! *41* !!! ]]
+  [[ array<char, 50>->array<char, 50> ][ !!! *<1* !!! ][ 117 ][ 19 ][ 12 ]]
+  [[ array<char, 50>->string ][ !!! *7* !!! ][ 124 ][ 26 ][ --- ]]
+  [[ array<char, 50>->container::string ][ !!! *4* !!! ][ 115 ][ 26 ][ --- ]]
+  [[ int->int ][ !!! *<1* !!! ][ 117 ][ 24 ][ --- ]]
+  [[ float->double ][ !!! *<1* !!! ][ 245 ][ 125 ][ --- ]]
+  [[ char->signed char ][ !!! *<1* !!! ][ 100 ][ 9 ][ --- ]]
+]
+[endsect]
+
+[section GNU C++ version 4.6.3]
+[table:id Performance Table ( GNU C++ version 4.6.3)
+[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
+  [[ string->char ][ !!! *<1* !!! ][ 142 ][ 10 ][ 18 ]]
+  [[ string->signed char ][ !!! *<1* !!! ][ 111 ][ 8 ][ 10 ]]
+  [[ string->unsigned char ][ !!! *<1* !!! ][ 101 ][ 8 ][ 10 ]]
+  [[ string->int ][ !!! *7* !!! ][ 110 ][ 20 ][ 24 ]]
+  [[ string->short ][ !!! *6* !!! ][ 109 ][ 20 ][ 25 ]]
+  [[ string->long int ][ !!! *7* !!! ][ 113 ][ 19 ][ 24 ]]
+  [[ string->long long ][ !!! *7* !!! ][ 116 ][ 24 ][ 23 ]]
+  [[ string->unsigned int ][ !!! *6* !!! ][ 110 ][ 19 ][ 23 ]]
+  [[ string->unsigned short ][ !!! *5* !!! ][ 116 ][ 18 ][ 23 ]]
+  [[ string->unsigned long int ][ !!! *7* !!! ][ 111 ][ 22 ][ 23 ]]
+  [[ string->unsigned long long ][ !!! *7* !!! ][ 108 ][ 20 ][ 22 ]]
+  [[ string->float ][ !!! *11* !!! ][ 161 ][ 54 ][ 38 ]]
+  [[ string->double ][ !!! *11* !!! ][ 146 ][ 56 ][ 41 ]]
+  [[ string->long double ][ 113 ][ 151 ][ 59 ][ !!! *43* !!! ]]
+  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 107 ][ 18 ][ 14 ]]
+  [[ string->string ][ !!! *2* !!! ][ 127 ][ 24 ][ --- ]]
+  [[ string->container::string ][ !!! *3* !!! ][ 142 ][ 26 ][ --- ]]
+  [[ string->char ][ !!! *7* !!! ][ 110 ][ 23 ][ 17 ]]
+  [[ string->signed char ][ !!! *7* !!! ][ 114 ][ 23 ][ 24 ]]
+  [[ string->unsigned char ][ !!! *7* !!! ][ 110 ][ 25 ][ 24 ]]
+  [[ int->string ][ !!! *12* !!! ][ 127 ][ 31 ][ 22 ]]
+  [[ short->string ][ !!! *13* !!! ][ 129 ][ 31 ][ 22 ]]
+  [[ long int->string ][ !!! *12* !!! ][ 125 ][ 30 ][ 22 ]]
+  [[ long long->string ][ !!! *13* !!! ][ 127 ][ 34 ][ 24 ]]
+  [[ unsigned int->string ][ !!! *13* !!! ][ 127 ][ 27 ][ 21 ]]
+  [[ unsigned short->string ][ !!! *12* !!! ][ 127 ][ 28 ][ 22 ]]
+  [[ unsigned long int->string ][ !!! *12* !!! ][ 131 ][ 27 ][ 22 ]]
+  [[ unsigned long long->string ][ !!! *12* !!! ][ 125 ][ 28 ][ 24 ]]
+  [[ float->string ][ 51 ][ 200 ][ 81 ][ !!! *40* !!! ]]
+  [[ double->string ][ 56 ][ 194 ][ 82 ][ !!! *48* !!! ]]
+  [[ long double->string ][ 65 ][ 220 ][ 82 ][ !!! *41* !!! ]]
+  [[ char*->char ][ !!! *<1* !!! ][ 104 ][ 10 ][ 9 ]]
+  [[ char*->signed char ][ !!! *<1* !!! ][ 101 ][ 10 ][ 11 ]]
+  [[ char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 12 ]]
+  [[ char*->int ][ !!! *6* !!! ][ 112 ][ 23 ][ 24 ]]
+  [[ char*->short ][ !!! *6* !!! ][ 115 ][ 21 ][ 23 ]]
+  [[ char*->long int ][ !!! *8* !!! ][ 111 ][ 21 ][ 24 ]]
+  [[ char*->long long ][ !!! *9* !!! ][ 112 ][ 21 ][ 30 ]]
+  [[ char*->unsigned int ][ !!! *7* !!! ][ 112 ][ 22 ][ 24 ]]
+  [[ char*->unsigned short ][ !!! *6* !!! ][ 119 ][ 19 ][ 23 ]]
+  [[ char*->unsigned long int ][ !!! *7* !!! ][ 115 ][ 22 ][ 23 ]]
+  [[ char*->unsigned long long ][ !!! *7* !!! ][ 115 ][ 20 ][ 23 ]]
+  [[ char*->float ][ !!! *12* !!! ][ 153 ][ 54 ][ 39 ]]
+  [[ char*->double ][ !!! *12* !!! ][ 153 ][ 61 ][ 41 ]]
+  [[ char*->long double ][ 108 ][ 160 ][ 61 ][ !!! *49* !!! ]]
+  [[ char*->array<char, 50> ][ !!! *<1* !!! ][ 107 ][ 20 ][ 14 ]]
+  [[ char*->string ][ !!! *7* !!! ][ 123 ][ 26 ][ --- ]]
+  [[ char*->container::string ][ !!! *2* !!! ][ 121 ][ 24 ][ --- ]]
+  [[ unsigned char*->char ][ !!! *<1* !!! ][ 97 ][ 10 ][ 9 ]]
+  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 98 ][ 10 ][ 12 ]]
+  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 12 ]]
+  [[ unsigned char*->int ][ !!! *6* !!! ][ 112 ][ 22 ][ 24 ]]
+  [[ unsigned char*->short ][ !!! *10* !!! ][ 111 ][ 24 ][ 24 ]]
+  [[ unsigned char*->long int ][ !!! *8* !!! ][ 110 ][ 23 ][ 24 ]]
+  [[ unsigned char*->long long ][ !!! *9* !!! ][ 115 ][ 21 ][ 25 ]]
+  [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 111 ][ 24 ][ 23 ]]
+  [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 118 ][ 19 ][ 23 ]]
+  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 112 ][ 21 ][ 23 ]]
+  [[ unsigned char*->unsigned long long ][ !!! *13* !!! ][ 109 ][ 20 ][ 23 ]]
+  [[ unsigned char*->float ][ !!! *12* !!! ][ 154 ][ 56 ][ 39 ]]
+  [[ unsigned char*->double ][ !!! *17* !!! ][ 150 ][ 58 ][ 41 ]]
+  [[ unsigned char*->long double ][ 108 ][ 149 ][ 68 ][ !!! *43* !!! ]]
+  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 107 ][ 19 ][ 15 ]]
+  [[ unsigned char*->string ][ !!! *8* !!! ][ 124 ][ 26 ][ --- ]]
+  [[ unsigned char*->container::string ][ !!! *4* !!! ][ 121 ][ 24 ][ --- ]]
+  [[ signed char*->char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 9 ]]
+  [[ signed char*->signed char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 10 ]]
+  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 12 ]]
+  [[ signed char*->int ][ !!! *6* !!! ][ 113 ][ 28 ][ 24 ]]
+  [[ signed char*->short ][ !!! *6* !!! ][ 110 ][ 21 ][ 25 ]]
+  [[ signed char*->long int ][ !!! *8* !!! ][ 110 ][ 21 ][ 24 ]]
+  [[ signed char*->long long ][ !!! *9* !!! ][ 116 ][ 21 ][ 24 ]]
+  [[ signed char*->unsigned int ][ !!! *7* !!! ][ 114 ][ 21 ][ 23 ]]
+  [[ signed char*->unsigned short ][ !!! *6* !!! ][ 116 ][ 20 ][ 23 ]]
+  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 113 ][ 27 ][ 23 ]]
+  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 110 ][ 20 ][ 23 ]]
+  [[ signed char*->float ][ !!! *12* !!! ][ 155 ][ 53 ][ 44 ]]
+  [[ signed char*->double ][ !!! *13* !!! ][ 150 ][ 60 ][ 42 ]]
+  [[ signed char*->long double ][ 108 ][ 151 ][ 62 ][ !!! *44* !!! ]]
+  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 107 ][ 19 ][ 15 ]]
+  [[ signed char*->string ][ !!! *8* !!! ][ 124 ][ 26 ][ --- ]]
+  [[ signed char*->container::string ][ !!! *4* !!! ][ 121 ][ 24 ][ --- ]]
+  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 103 ][ 14 ][ 10 ]]
+  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 102 ][ 15 ][ 12 ]]
+  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 102 ][ 14 ][ 12 ]]
+  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 115 ][ 23 ][ 24 ]]
+  [[ iterator_range<char*>->short ][ !!! *5* !!! ][ 110 ][ 22 ][ 24 ]]
+  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 109 ][ 22 ][ 29 ]]
+  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 111 ][ 24 ][ 28 ]]
+  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 114 ][ 22 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned short ][ !!! *5* !!! ][ 115 ][ 20 ][ 22 ]]
+  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 123 ][ 26 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 110 ][ 23 ][ 24 ]]
+  [[ iterator_range<char*>->float ][ !!! *11* !!! ][ 153 ][ 38 ][ 38 ]]
+  [[ iterator_range<char*>->double ][ !!! *11* !!! ][ 140 ][ 43 ][ 40 ]]
+  [[ iterator_range<char*>->long double ][ 108 ][ 147 ][ !!! *41* !!! ][ 46 ]]
+  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 109 ][ 22 ][ 15 ]]
+  [[ iterator_range<char*>->string ][ !!! *8* !!! ][ 122 ][ 29 ][ --- ]]
+  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 117 ][ 23 ][ --- ]]
+  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 98 ][ 10 ][ 9 ]]
+  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 99 ][ 9 ][ 12 ]]
+  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 102 ][ 9 ][ 12 ]]
+  [[ array<char, 50>->int ][ !!! *6* !!! ][ 119 ][ 23 ][ 23 ]]
+  [[ array<char, 50>->short ][ !!! *6* !!! ][ 111 ][ 21 ][ 26 ]]
+  [[ array<char, 50>->long int ][ !!! *7* !!! ][ 115 ][ 20 ][ 28 ]]
+  [[ array<char, 50>->long long ][ !!! *9* !!! ][ 110 ][ 21 ][ 26 ]]
+  [[ array<char, 50>->unsigned int ][ !!! *6* !!! ][ 115 ][ 22 ][ 23 ]]
+  [[ array<char, 50>->unsigned short ][ !!! *6* !!! ][ 115 ][ 19 ][ 23 ]]
+  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 118 ][ 23 ][ 23 ]]
+  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 109 ][ 20 ][ 24 ]]
+  [[ array<char, 50>->float ][ !!! *12* !!! ][ 160 ][ 53 ][ 38 ]]
+  [[ array<char, 50>->double ][ !!! *11* !!! ][ 147 ][ 57 ][ 41 ]]
+  [[ array<char, 50>->long double ][ 109 ][ 154 ][ 59 ][ !!! *42* !!! ]]
+  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 105 ][ 19 ][ 14 ]]
+  [[ array<char, 50>->string ][ !!! *8* !!! ][ 129 ][ 26 ][ --- ]]
+  [[ array<char, 50>->container::string ][ !!! *4* !!! ][ 116 ][ 25 ][ --- ]]
+  [[ int->int ][ !!! *<1* !!! ][ 118 ][ 24 ][ --- ]]
+  [[ float->double ][ !!! *<1* !!! ][ 242 ][ 132 ][ --- ]]
+  [[ char->signed char ][ !!! *<1* !!! ][ 94 ][ 8 ][ --- ]]
+]
+[endsect]
+
+[section GNU C++ version 4.5.3]
+[table:id Performance Table ( GNU C++ version 4.5.3)
+[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
+  [[ string->char ][ !!! *<1* !!! ][ 153 ][ 15 ][ 9 ]]
+  [[ string->signed char ][ !!! *<1* !!! ][ 134 ][ 8 ][ 10 ]]
+  [[ string->unsigned char ][ !!! *<1* !!! ][ 97 ][ 8 ][ 14 ]]
+  [[ string->int ][ !!! *7* !!! ][ 115 ][ 22 ][ 22 ]]
+  [[ string->short ][ !!! *5* !!! ][ 112 ][ 19 ][ 21 ]]
+  [[ string->long int ][ !!! *7* !!! ][ 110 ][ 19 ][ 24 ]]
+  [[ string->long long ][ !!! *7* !!! ][ 115 ][ 21 ][ 23 ]]
+  [[ string->unsigned int ][ !!! *6* !!! ][ 113 ][ 20 ][ 23 ]]
+  [[ string->unsigned short ][ !!! *5* !!! ][ 116 ][ 18 ][ 23 ]]
+  [[ string->unsigned long int ][ !!! *7* !!! ][ 111 ][ 20 ][ 23 ]]
+  [[ string->unsigned long long ][ !!! *7* !!! ][ 115 ][ 18 ][ 23 ]]
+  [[ string->float ][ !!! *14* !!! ][ 153 ][ 55 ][ 38 ]]
+  [[ string->double ][ !!! *11* !!! ][ 151 ][ 60 ][ 38 ]]
+  [[ string->long double ][ 107 ][ 151 ][ 59 ][ !!! *44* !!! ]]
+  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 107 ][ 18 ][ 12 ]]
+  [[ string->string ][ !!! *2* !!! ][ 129 ][ 49 ][ --- ]]
+  [[ string->container::string ][ !!! *9* !!! ][ 199 ][ 22 ][ --- ]]
+  [[ string->char ][ !!! *7* !!! ][ 114 ][ 27 ][ 16 ]]
+  [[ string->signed char ][ !!! *7* !!! ][ 116 ][ 32 ][ 23 ]]
+  [[ string->unsigned char ][ !!! *7* !!! ][ 114 ][ 27 ][ 22 ]]
+  [[ int->string ][ !!! *11* !!! ][ 125 ][ 31 ][ 21 ]]
+  [[ short->string ][ !!! *11* !!! ][ 126 ][ 33 ][ 21 ]]
+  [[ long int->string ][ !!! *11* !!! ][ 126 ][ 32 ][ 22 ]]
+  [[ long long->string ][ !!! *11* !!! ][ 118 ][ 30 ][ 23 ]]
+  [[ unsigned int->string ][ !!! *11* !!! ][ 125 ][ 31 ][ 20 ]]
+  [[ unsigned short->string ][ !!! *12* !!! ][ 128 ][ 30 ][ 21 ]]
+  [[ unsigned long int->string ][ !!! *11* !!! ][ 131 ][ 30 ][ 21 ]]
+  [[ unsigned long long->string ][ !!! *11* !!! ][ 127 ][ 32 ][ 23 ]]
+  [[ float->string ][ 49 ][ 197 ][ 92 ][ !!! *39* !!! ]]
+  [[ double->string ][ 56 ][ 195 ][ 80 ][ !!! *43* !!! ]]
+  [[ long double->string ][ 60 ][ 222 ][ 88 ][ !!! *42* !!! ]]
+  [[ char*->char ][ !!! *<1* !!! ][ 100 ][ 10 ][ 9 ]]
+  [[ char*->signed char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 10 ]]
+  [[ char*->unsigned char ][ !!! *<1* !!! ][ 106 ][ 10 ][ 10 ]]
+  [[ char*->int ][ !!! *7* !!! ][ 113 ][ 23 ][ 22 ]]
+  [[ char*->short ][ !!! *6* !!! ][ 113 ][ 21 ][ 23 ]]
+  [[ char*->long int ][ !!! *8* !!! ][ 116 ][ 21 ][ 23 ]]
+  [[ char*->long long ][ !!! *8* !!! ][ 115 ][ 21 ][ 21 ]]
+  [[ char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 25 ][ 22 ]]
+  [[ char*->unsigned short ][ !!! *6* !!! ][ 119 ][ 20 ][ 23 ]]
+  [[ char*->unsigned long int ][ !!! *8* !!! ][ 114 ][ 23 ][ 23 ]]
+  [[ char*->unsigned long long ][ !!! *7* !!! ][ 111 ][ 20 ][ 24 ]]
+  [[ char*->float ][ !!! *16* !!! ][ 154 ][ 54 ][ 38 ]]
+  [[ char*->double ][ !!! *12* !!! ][ 149 ][ 59 ][ 40 ]]
+  [[ char*->long double ][ 107 ][ 166 ][ 62 ][ !!! *44* !!! ]]
+  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 108 ][ 20 ][ 12 ]]
+  [[ char*->string ][ !!! *8* !!! ][ 125 ][ 28 ][ --- ]]
+  [[ char*->container::string ][ !!! *2* !!! ][ 123 ][ 24 ][ --- ]]
+  [[ unsigned char*->char ][ !!! *<1* !!! ][ 104 ][ 11 ][ 9 ]]
+  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 106 ][ 10 ][ 10 ]]
+  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 101 ][ 10 ][ 10 ]]
+  [[ unsigned char*->int ][ !!! *7* !!! ][ 117 ][ 22 ][ 24 ]]
+  [[ unsigned char*->short ][ !!! *6* !!! ][ 111 ][ 26 ][ 22 ]]
+  [[ unsigned char*->long int ][ !!! *8* !!! ][ 111 ][ 23 ][ 23 ]]
+  [[ unsigned char*->long long ][ !!! *8* !!! ][ 114 ][ 21 ][ 23 ]]
+  [[ unsigned char*->unsigned int ][ !!! *7* !!! ][ 115 ][ 20 ][ 25 ]]
+  [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 113 ][ 20 ][ 22 ]]
+  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 115 ][ 25 ][ 24 ]]
+  [[ unsigned char*->unsigned long long ][ !!! *7* !!! ][ 113 ][ 25 ][ 25 ]]
+  [[ unsigned char*->float ][ !!! *16* !!! ][ 158 ][ 55 ][ 38 ]]
+  [[ unsigned char*->double ][ !!! *12* !!! ][ 155 ][ 62 ][ 40 ]]
+  [[ unsigned char*->long double ][ 108 ][ 153 ][ 60 ][ !!! *41* !!! ]]
+  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 111 ][ 19 ][ 12 ]]
+  [[ unsigned char*->string ][ !!! *8* !!! ][ 125 ][ 30 ][ --- ]]
+  [[ unsigned char*->container::string ][ !!! *4* !!! ][ 121 ][ 23 ][ --- ]]
+  [[ signed char*->char ][ !!! *<1* !!! ][ 98 ][ 14 ][ 9 ]]
+  [[ signed char*->signed char ][ !!! *<1* !!! ][ 98 ][ 11 ][ 10 ]]
+  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 10 ]]
+  [[ signed char*->int ][ !!! *7* !!! ][ 111 ][ 22 ][ 24 ]]
+  [[ signed char*->short ][ !!! *6* !!! ][ 123 ][ 22 ][ 23 ]]
+  [[ signed char*->long int ][ !!! *8* !!! ][ 112 ][ 21 ][ 23 ]]
+  [[ signed char*->long long ][ !!! *8* !!! ][ 114 ][ 24 ][ 24 ]]
+  [[ signed char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 19 ][ 22 ]]
+  [[ signed char*->unsigned short ][ !!! *6* !!! ][ 112 ][ 21 ][ 24 ]]
+  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 114 ][ 23 ][ 22 ]]
+  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 116 ][ 22 ][ 24 ]]
+  [[ signed char*->float ][ !!! *16* !!! ][ 156 ][ 55 ][ 38 ]]
+  [[ signed char*->double ][ !!! *12* !!! ][ 151 ][ 59 ][ 39 ]]
+  [[ signed char*->long double ][ 111 ][ 159 ][ 60 ][ !!! *44* !!! ]]
+  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 107 ][ 24 ][ 12 ]]
+  [[ signed char*->string ][ !!! *8* !!! ][ 122 ][ 28 ][ --- ]]
+  [[ signed char*->container::string ][ !!! *4* !!! ][ 122 ][ 23 ][ --- ]]
+  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 103 ][ 13 ][ 10 ]]
+  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 103 ][ 13 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 104 ][ 14 ][ 10 ]]
+  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 115 ][ 23 ][ 24 ]]
+  [[ iterator_range<char*>->short ][ !!! *7* !!! ][ 111 ][ 21 ][ 24 ]]
+  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 108 ][ 21 ][ 23 ]]
+  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 114 ][ 24 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 111 ][ 22 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned short ][ !!! *5* !!! ][ 114 ][ 20 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 119 ][ 25 ][ 24 ]]
+  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 110 ][ 20 ][ 24 ]]
+  [[ iterator_range<char*>->float ][ !!! *15* !!! ][ 148 ][ 38 ][ 40 ]]
+  [[ iterator_range<char*>->double ][ !!! *10* !!! ][ 146 ][ 41 ][ 40 ]]
+  [[ iterator_range<char*>->long double ][ 103 ][ 138 ][ !!! *39* !!! ][ 42 ]]
+  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 109 ][ 22 ][ 13 ]]
+  [[ iterator_range<char*>->string ][ !!! *7* !!! ][ 121 ][ 32 ][ --- ]]
+  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 120 ][ 24 ][ --- ]]
+  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 102 ][ 9 ][ 9 ]]
+  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 97 ][ 9 ][ 10 ]]
+  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 99 ][ 9 ][ 10 ]]
+  [[ array<char, 50>->int ][ !!! *7* !!! ][ 114 ][ 22 ][ 23 ]]
+  [[ array<char, 50>->short ][ !!! *6* !!! ][ 116 ][ 21 ][ 23 ]]
+  [[ array<char, 50>->long int ][ !!! *7* !!! ][ 109 ][ 20 ][ 23 ]]
+  [[ array<char, 50>->long long ][ !!! *7* !!! ][ 114 ][ 21 ][ 23 ]]
+  [[ array<char, 50>->unsigned int ][ !!! *7* !!! ][ 119 ][ 20 ][ 25 ]]
+  [[ array<char, 50>->unsigned short ][ !!! *6* !!! ][ 120 ][ 20 ][ 23 ]]
+  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 113 ][ 20 ][ 21 ]]
+  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 112 ][ 20 ][ 24 ]]
+  [[ array<char, 50>->float ][ !!! *16* !!! ][ 155 ][ 57 ][ 38 ]]
+  [[ array<char, 50>->double ][ !!! *11* !!! ][ 152 ][ 59 ][ 42 ]]
+  [[ array<char, 50>->long double ][ 107 ][ 152 ][ 60 ][ !!! *41* !!! ]]
+  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 111 ][ 20 ][ 12 ]]
+  [[ array<char, 50>->string ][ !!! *8* !!! ][ 123 ][ 36 ][ --- ]]
+  [[ array<char, 50>->container::string ][ !!! *4* !!! ][ 128 ][ 23 ][ --- ]]
+  [[ int->int ][ !!! *<1* !!! ][ 118 ][ 26 ][ --- ]]
+  [[ float->double ][ !!! *<1* !!! ][ 233 ][ 120 ][ --- ]]
+  [[ char->signed char ][ !!! *<1* !!! ][ 97 ][ 8 ][ --- ]]
+]
+[endsect]
+
+[section GNU C++ version 4.4.7]
+[table:id Performance Table ( GNU C++ version 4.4.7)
+[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
+  [[ string->char ][ !!! *<1* !!! ][ 111 ][ 8 ][ 9 ]]
+  [[ string->signed char ][ !!! *<1* !!! ][ 100 ][ 8 ][ 10 ]]
+  [[ string->unsigned char ][ !!! *<1* !!! ][ 102 ][ 8 ][ 11 ]]
+  [[ string->int ][ !!! *6* !!! ][ 114 ][ 21 ][ 23 ]]
+  [[ string->short ][ !!! *5* !!! ][ 120 ][ 21 ][ 29 ]]
+  [[ string->long int ][ !!! *7* !!! ][ 114 ][ 22 ][ 26 ]]
+  [[ string->long long ][ !!! *7* !!! ][ 118 ][ 21 ][ 23 ]]
+  [[ string->unsigned int ][ !!! *7* !!! ][ 115 ][ 21 ][ 23 ]]
+  [[ string->unsigned short ][ !!! *5* !!! ][ 119 ][ 18 ][ 22 ]]
+  [[ string->unsigned long int ][ !!! *7* !!! ][ 115 ][ 20 ][ 23 ]]
+  [[ string->unsigned long long ][ !!! *9* !!! ][ 116 ][ 26 ][ 24 ]]
+  [[ string->float ][ !!! *12* !!! ][ 165 ][ 53 ][ 40 ]]
+  [[ string->double ][ !!! *12* !!! ][ 154 ][ 54 ][ 40 ]]
+  [[ string->long double ][ 112 ][ 148 ][ 61 ][ !!! *45* !!! ]]
+  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 120 ][ 19 ][ 14 ]]
+  [[ string->string ][ !!! *2* !!! ][ 141 ][ 55 ][ --- ]]
+  [[ string->container::string ][ !!! *2* !!! ][ 164 ][ 36 ][ --- ]]
+  [[ string->char ][ !!! *7* !!! ][ 161 ][ 24 ][ 18 ]]
+  [[ string->signed char ][ !!! *6* !!! ][ 109 ][ 25 ][ 24 ]]
+  [[ string->unsigned char ][ !!! *6* !!! ][ 109 ][ 25 ][ 25 ]]
+  [[ int->string ][ !!! *11* !!! ][ 128 ][ 32 ][ 23 ]]
+  [[ short->string ][ !!! *12* !!! ][ 136 ][ 54 ][ 34 ]]
+  [[ long int->string ][ !!! *15* !!! ][ 187 ][ 41 ][ 23 ]]
+  [[ long long->string ][ !!! *11* !!! ][ 128 ][ 30 ][ 29 ]]
+  [[ unsigned int->string ][ !!! *13* !!! ][ 124 ][ 29 ][ 23 ]]
+  [[ unsigned short->string ][ !!! *11* !!! ][ 128 ][ 30 ][ 22 ]]
+  [[ unsigned long int->string ][ !!! *11* !!! ][ 131 ][ 30 ][ 22 ]]
+  [[ unsigned long long->string ][ !!! *11* !!! ][ 133 ][ 33 ][ 29 ]]
+  [[ float->string ][ 52 ][ 187 ][ 90 ][ !!! *39* !!! ]]
+  [[ double->string ][ 58 ][ 190 ][ 86 ][ !!! *45* !!! ]]
+  [[ long double->string ][ 70 ][ 218 ][ 88 ][ !!! *47* !!! ]]
+  [[ char*->char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 9 ]]
+  [[ char*->signed char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 10 ]]
+  [[ char*->unsigned char ][ !!! *<1* !!! ][ 100 ][ 12 ][ 10 ]]
+  [[ char*->int ][ !!! *6* !!! ][ 117 ][ 23 ][ 21 ]]
+  [[ char*->short ][ !!! *6* !!! ][ 115 ][ 28 ][ 23 ]]
+  [[ char*->long int ][ !!! *7* !!! ][ 119 ][ 22 ][ 24 ]]
+  [[ char*->long long ][ !!! *7* !!! ][ 114 ][ 23 ][ 22 ]]
+  [[ char*->unsigned int ][ !!! *6* !!! ][ 113 ][ 21 ][ 21 ]]
+  [[ char*->unsigned short ][ !!! *6* !!! ][ 120 ][ 21 ][ 21 ]]
+  [[ char*->unsigned long int ][ !!! *7* !!! ][ 117 ][ 25 ][ 23 ]]
+  [[ char*->unsigned long long ][ !!! *7* !!! ][ 119 ][ 23 ][ 21 ]]
+  [[ char*->float ][ !!! *13* !!! ][ 160 ][ 61 ][ 36 ]]
+  [[ char*->double ][ !!! *13* !!! ][ 152 ][ 54 ][ 40 ]]
+  [[ char*->long double ][ 116 ][ 173 ][ 58 ][ !!! *43* !!! ]]
+  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 121 ][ 20 ][ 12 ]]
+  [[ char*->string ][ !!! *7* !!! ][ 126 ][ 29 ][ --- ]]
+  [[ char*->container::string ][ !!! *2* !!! ][ 119 ][ 27 ][ --- ]]
+  [[ unsigned char*->char ][ !!! *<1* !!! ][ 96 ][ 12 ][ 9 ]]
+  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 95 ][ 11 ][ 12 ]]
+  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 95 ][ 12 ][ 12 ]]
+  [[ unsigned char*->int ][ !!! *6* !!! ][ 113 ][ 27 ][ 24 ]]
+  [[ unsigned char*->short ][ !!! *6* !!! ][ 120 ][ 23 ][ 21 ]]
+  [[ unsigned char*->long int ][ !!! *7* !!! ][ 114 ][ 22 ][ 23 ]]
+  [[ unsigned char*->long long ][ !!! *7* !!! ][ 114 ][ 23 ][ 23 ]]
+  [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 115 ][ 23 ][ 23 ]]
+  [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 120 ][ 21 ][ 23 ]]
+  [[ unsigned char*->unsigned long int ][ !!! *7* !!! ][ 117 ][ 23 ][ 21 ]]
+  [[ unsigned char*->unsigned long long ][ !!! *7* !!! ][ 121 ][ 23 ][ 21 ]]
+  [[ unsigned char*->float ][ !!! *12* !!! ][ 161 ][ 58 ][ 39 ]]
+  [[ unsigned char*->double ][ !!! *13* !!! ][ 153 ][ 54 ][ 38 ]]
+  [[ unsigned char*->long double ][ 110 ][ 150 ][ 62 ][ !!! *43* !!! ]]
+  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 113 ][ 20 ][ 12 ]]
+  [[ unsigned char*->string ][ !!! *8* !!! ][ 124 ][ 30 ][ --- ]]
+  [[ unsigned char*->container::string ][ !!! *3* !!! ][ 118 ][ 27 ][ --- ]]
+  [[ signed char*->char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 9 ]]
+  [[ signed char*->signed char ][ !!! *<1* !!! ][ 102 ][ 12 ][ 10 ]]
+  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 12 ][ 10 ]]
+  [[ signed char*->int ][ !!! *6* !!! ][ 114 ][ 30 ][ 23 ]]
+  [[ signed char*->short ][ !!! *6* !!! ][ 118 ][ 23 ][ 23 ]]
+  [[ signed char*->long int ][ !!! *7* !!! ][ 119 ][ 22 ][ 21 ]]
+  [[ signed char*->long long ][ !!! *7* !!! ][ 114 ][ 23 ][ 26 ]]
+  [[ signed char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 26 ][ 23 ]]
+  [[ signed char*->unsigned short ][ !!! *6* !!! ][ 121 ][ 22 ][ 23 ]]
+  [[ signed char*->unsigned long int ][ !!! *7* !!! ][ 126 ][ 23 ][ 21 ]]
+  [[ signed char*->unsigned long long ][ !!! *7* !!! ][ 114 ][ 22 ][ 21 ]]
+  [[ signed char*->float ][ !!! *12* !!! ][ 163 ][ 57 ][ 39 ]]
+  [[ signed char*->double ][ !!! *13* !!! ][ 156 ][ 53 ][ 40 ]]
+  [[ signed char*->long double ][ 112 ][ 156 ][ 56 ][ !!! *42* !!! ]]
+  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 117 ][ 20 ][ 12 ]]
+  [[ signed char*->string ][ !!! *8* !!! ][ 127 ][ 28 ][ --- ]]
+  [[ signed char*->container::string ][ !!! *4* !!! ][ 112 ][ 27 ][ --- ]]
+  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 103 ][ 14 ][ 9 ]]
+  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 104 ][ 16 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 103 ][ 16 ][ 10 ]]
+  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 121 ][ 22 ][ 21 ]]
+  [[ iterator_range<char*>->short ][ !!! *7* !!! ][ 112 ][ 23 ][ 23 ]]
+  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 115 ][ 24 ][ 23 ]]
+  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 113 ][ 24 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 117 ][ 26 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned short ][ !!! *5* !!! ][ 120 ][ 20 ][ 23 ]]
+  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 124 ][ 28 ][ 21 ]]
+  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 113 ][ 22 ][ 21 ]]
+  [[ iterator_range<char*>->float ][ !!! *11* !!! ][ 190 ][ 58 ][ 63 ]]
+  [[ iterator_range<char*>->double ][ !!! *20* !!! ][ 194 ][ 44 ][ 39 ]]
+  [[ iterator_range<char*>->long double ][ 116 ][ 145 ][ 46 ][ !!! *44* !!! ]]
+  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 116 ][ 23 ][ 15 ]]
+  [[ iterator_range<char*>->string ][ !!! *7* !!! ][ 127 ][ 33 ][ --- ]]
+  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 112 ][ 24 ][ --- ]]
+  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 98 ][ 11 ][ 10 ]]
+  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 99 ][ 12 ][ 15 ]]
+  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 100 ][ 11 ][ 10 ]]
+  [[ array<char, 50>->int ][ !!! *6* !!! ][ 114 ][ 27 ][ 22 ]]
+  [[ array<char, 50>->short ][ !!! *5* !!! ][ 113 ][ 23 ][ 23 ]]
+  [[ array<char, 50>->long int ][ !!! *7* !!! ][ 118 ][ 22 ][ 23 ]]
+  [[ array<char, 50>->long long ][ !!! *7* !!! ][ 114 ][ 26 ][ 23 ]]
+  [[ array<char, 50>->unsigned int ][ !!! *6* !!! ][ 113 ][ 27 ][ 23 ]]
+  [[ array<char, 50>->unsigned short ][ !!! *5* !!! ][ 124 ][ 21 ][ 23 ]]
+  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 116 ][ 23 ][ 21 ]]
+  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 115 ][ 22 ][ 21 ]]
+  [[ array<char, 50>->float ][ !!! *11* !!! ][ 162 ][ 58 ][ 36 ]]
+  [[ array<char, 50>->double ][ !!! *13* !!! ][ 155 ][ 54 ][ 44 ]]
+  [[ array<char, 50>->long double ][ 111 ][ 149 ][ 55 ][ !!! *42* !!! ]]
+  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 114 ][ 18 ][ 14 ]]
+  [[ array<char, 50>->string ][ !!! *7* !!! ][ 129 ][ 29 ][ --- ]]
+  [[ array<char, 50>->container::string ][ !!! *3* !!! ][ 113 ][ 26 ][ --- ]]
+  [[ int->int ][ !!! *<1* !!! ][ 114 ][ 25 ][ --- ]]
+  [[ float->double ][ !!! *<1* !!! ][ 236 ][ 121 ][ --- ]]
+  [[ char->signed char ][ !!! *<1* !!! ][ 97 ][ 8 ][ --- ]]
+]
+[endsect]
+
+[section Microsoft Visual C++ version 11.0]
+[table:id Performance Table ( Microsoft Visual C++ version 11.0)
+[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
+  [[ string->char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 7 ]]
+  [[ string->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
+  [[ string->unsigned char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
+  [[ string->int ][ !!! *8* !!! ][ 71 ][ 49 ][ 10 ]]
+  [[ string->short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ string->long int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ string->long long ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ string->unsigned int ][ !!! *8* !!! ][ 72 ][ 46 ][ 10 ]]
+  [[ string->unsigned short ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ string->unsigned long int ][ !!! *8* !!! ][ 70 ][ 45 ][ 10 ]]
+  [[ string->unsigned long long ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ string->float ][ !!! *14* !!! ][ 586 ][ 559 ][ 37 ]]
+  [[ string->double ][ 601 ][ 618 ][ 592 ][ !!! *37* !!! ]]
+  [[ string->long double ][ 629 ][ 645 ][ 618 ][ !!! *37* !!! ]]
+  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 52 ][ 28 ][ 11 ]]
+  [[ string->string ][ !!! *1* !!! ][ 59 ][ 34 ][ --- ]]
+  [[ string->container::string ][ !!! *2* !!! ][ 54 ][ 31 ][ --- ]]
+  [[ string->char ][ !!! *2* !!! ][ 50 ][ 24 ][ 9 ]]
+  [[ string->signed char ][ !!! *2* !!! ][ 50 ][ 24 ][ 13 ]]
+  [[ string->unsigned char ][ !!! *2* !!! ][ 50 ][ 24 ][ 13 ]]
+  [[ int->string ][ !!! *9* !!! ][ 86 ][ 59 ][ 13 ]]
+  [[ short->string ][ !!! *9* !!! ][ 86 ][ 59 ][ 13 ]]
+  [[ long int->string ][ !!! *9* !!! ][ 87 ][ 59 ][ 13 ]]
+  [[ long long->string ][ !!! *9* !!! ][ 88 ][ 62 ][ 13 ]]
+  [[ unsigned int->string ][ !!! *9* !!! ][ 87 ][ 60 ][ 13 ]]
+  [[ unsigned short->string ][ !!! *9* !!! ][ 91 ][ 63 ][ 13 ]]
+  [[ unsigned long int->string ][ !!! *9* !!! ][ 91 ][ 62 ][ 13 ]]
+  [[ unsigned long long->string ][ !!! *9* !!! ][ 88 ][ 60 ][ 13 ]]
+  [[ float->string ][ 73 ][ 167 ][ 137 ][ !!! *56* !!! ]]
+  [[ double->string ][ 77 ][ 176 ][ 144 ][ !!! *64* !!! ]]
+  [[ long double->string ][ 79 ][ 175 ][ 143 ][ !!! *63* !!! ]]
+  [[ char*->char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 7 ]]
+  [[ char*->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
+  [[ char*->unsigned char ][ !!! *<1* !!! ][ 44 ][ 17 ][ 8 ]]
+  [[ char*->int ][ !!! *8* !!! ][ 70 ][ 47 ][ 10 ]]
+  [[ char*->short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
+  [[ char*->long int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ char*->long long ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ char*->unsigned int ][ !!! *8* !!! ][ 72 ][ 46 ][ 10 ]]
+  [[ char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ char*->unsigned long int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 45 ][ 10 ]]
+  [[ char*->float ][ !!! *14* !!! ][ 586 ][ 560 ][ 37 ]]
+  [[ char*->double ][ 598 ][ 617 ][ 597 ][ !!! *40* !!! ]]
+  [[ char*->long double ][ 635 ][ 653 ][ 622 ][ !!! *37* !!! ]]
+  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 53 ][ 28 ][ 11 ]]
+  [[ char*->string ][ !!! *1* !!! ][ 59 ][ 35 ][ --- ]]
+  [[ char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
+  [[ unsigned char*->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
+  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
+  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
+  [[ unsigned char*->int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ unsigned char*->short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ unsigned char*->long int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ unsigned char*->long long ][ !!! *8* !!! ][ 72 ][ 47 ][ 11 ]]
+  [[ unsigned char*->unsigned int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ unsigned char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
+  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 71 ][ 46 ][ 10 ]]
+  [[ unsigned char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 45 ][ 11 ]]
+  [[ unsigned char*->float ][ !!! *14* !!! ][ 589 ][ 564 ][ 38 ]]
+  [[ unsigned char*->double ][ 601 ][ 615 ][ 588 ][ !!! *37* !!! ]]
+  [[ unsigned char*->long double ][ 628 ][ 644 ][ 620 ][ !!! *38* !!! ]]
+  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 54 ][ 28 ][ 11 ]]
+  [[ unsigned char*->string ][ !!! *2* !!! ][ 59 ][ 36 ][ --- ]]
+  [[ unsigned char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
+  [[ signed char*->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
+  [[ signed char*->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
+  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
+  [[ signed char*->int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ signed char*->short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
+  [[ signed char*->long int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ signed char*->long long ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ signed char*->unsigned int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ signed char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 46 ][ 11 ]]
+  [[ signed char*->float ][ !!! *14* !!! ][ 586 ][ 562 ][ 37 ]]
+  [[ signed char*->double ][ 603 ][ 615 ][ 589 ][ !!! *37* !!! ]]
+  [[ signed char*->long double ][ 630 ][ 644 ][ 623 ][ !!! *40* !!! ]]
+  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 54 ][ 28 ][ 11 ]]
+  [[ signed char*->string ][ !!! *2* !!! ][ 59 ][ 36 ][ --- ]]
+  [[ signed char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
+  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 74 ][ 46 ][ 7 ]]
+  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 75 ][ 46 ][ 8 ]]
+  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 74 ][ 46 ][ 8 ]]
+  [[ iterator_range<char*>->int ][ !!! *8* !!! ][ 98 ][ 70 ][ 10 ]]
+  [[ iterator_range<char*>->short ][ !!! *8* !!! ][ 103 ][ 72 ][ 10 ]]
+  [[ iterator_range<char*>->long int ][ !!! *8* !!! ][ 111 ][ 71 ][ 10 ]]
+  [[ iterator_range<char*>->long long ][ !!! *8* !!! ][ 98 ][ 70 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned int ][ !!! *7* !!! ][ 103 ][ 76 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned short ][ !!! *8* !!! ][ 104 ][ 75 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 104 ][ 71 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned long long ][ !!! *8* !!! ][ 99 ][ 71 ][ 11 ]]
+  [[ iterator_range<char*>->float ][ !!! *13* !!! ][ 123 ][ 93 ][ 37 ]]
+  [[ iterator_range<char*>->double ][ 603 ][ 111 ][ 82 ][ !!! *38* !!! ]]
+  [[ iterator_range<char*>->long double ][ 629 ][ 116 ][ 83 ][ !!! *38* !!! ]]
+  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 82 ][ 52 ][ 11 ]]
+  [[ iterator_range<char*>->string ][ !!! *2* !!! ][ 83 ][ 56 ][ --- ]]
+  [[ iterator_range<char*>->container::string ][ !!! *2* !!! ][ 81 ][ 53 ][ --- ]]
+  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
+  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
+  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
+  [[ array<char, 50>->int ][ !!! *8* !!! ][ 73 ][ 46 ][ 10 ]]
+  [[ array<char, 50>->short ][ !!! *8* !!! ][ 73 ][ 47 ][ 10 ]]
+  [[ array<char, 50>->long int ][ !!! *8* !!! ][ 75 ][ 48 ][ 10 ]]
+  [[ array<char, 50>->long long ][ !!! *8* !!! ][ 73 ][ 48 ][ 11 ]]
+  [[ array<char, 50>->unsigned int ][ !!! *8* !!! ][ 73 ][ 47 ][ 10 ]]
+  [[ array<char, 50>->unsigned short ][ !!! *8* !!! ][ 74 ][ 50 ][ 10 ]]
+  [[ array<char, 50>->unsigned long int ][ !!! *8* !!! ][ 71 ][ 46 ][ 10 ]]
+  [[ array<char, 50>->unsigned long long ][ !!! *8* !!! ][ 70 ][ 47 ][ 11 ]]
+  [[ array<char, 50>->float ][ !!! *14* !!! ][ 586 ][ 567 ][ 37 ]]
+  [[ array<char, 50>->double ][ 599 ][ 624 ][ 590 ][ !!! *37* !!! ]]
+  [[ array<char, 50>->long double ][ 632 ][ 643 ][ 618 ][ !!! *37* !!! ]]
+  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 52 ][ 28 ][ 11 ]]
+  [[ array<char, 50>->string ][ !!! *2* !!! ][ 59 ][ 34 ][ --- ]]
+  [[ array<char, 50>->container::string ][ !!! *3* !!! ][ 55 ][ 30 ][ --- ]]
+  [[ int->int ][ !!! *<1* !!! ][ 105 ][ 79 ][ --- ]]
+  [[ float->double ][ !!! *<1* !!! ][ 226 ][ 188 ][ --- ]]
+  [[ char->signed char ][ !!! *<1* !!! ][ 40 ][ 16 ][ --- ]]
+]
+[endsect]
+
+
+
+[/ END of section, generated by performance measuring program ]
+[endsect]
+
@@ -0,0 +1,35 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+//[lexical_cast_args_example
+//`The following example treats command line arguments as a sequence of numeric data
+
+#include <boost/lexical_cast.hpp>
+#include <vector>
+
+int main(int /*argc*/, char * argv[])
+{
+    using boost::lexical_cast;
+    using boost::bad_lexical_cast;
+
+    std::vector<short> args;
+
+    while (*++argv)
+    {
+        try
+        {
+            args.push_back(lexical_cast<short>(*argv));
+        }
+        catch(const bad_lexical_cast &)
+        {
+            args.push_back(0);
+        }
+    }
+
+    // ...
+}
+
+//] [/lexical_cast_args_example]
@@ -0,0 +1,61 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+
+//[lexical_cast_stringize
+/*`
+    In this example we'll make a `stringize` method that accepts a sequence, converts
+    each element of the sequence into string and appends that string to the result.
+
+    Example is based on the example from the [@http://www.packtpub.com/boost-cplusplus-application-development-cookbook/book Boost C++ Application Development Cookbook]
+    by Antony Polukhin, ISBN 9781849514880.
+
+    Step 1: Making a functor that converts any type to a string and remembers result:
+*/
+
+#include <boost/lexical_cast.hpp>
+
+struct stringize_functor {
+private:
+    std::string& result;
+
+public:
+    explicit stringize_functor(std::string& res)
+        : result(res)
+    {}
+
+    template <class T>
+    void operator()(const T& v) const {
+        result += boost::lexical_cast<std::string>(v);
+    }
+};
+
+//` Step 2: Applying `stringize_functor` to each element in sequence:
+#include <boost/fusion/include/for_each.hpp>
+template <class Sequence>
+std::string stringize(const Sequence& seq) {
+    std::string result;
+    boost::fusion::for_each(seq, stringize_functor(result));
+    return result;
+}
+
+//` Step 3: Using the `stringize` with different types:
+#include <cassert>
+#include <boost/fusion/adapted/boost_tuple.hpp>
+#include <boost/fusion/adapted/std_pair.hpp>
+
+int main() {
+    boost::tuple<char, int, char, int> decim('-', 10, 'e', 5);
+    assert(stringize(decim) == "-10e5");
+
+    std::pair<short, std::string> value_and_type(270, "Kelvin");
+    assert(stringize(value_and_type) == "270Kelvin");
+}
+
+//] [/lexical_cast_stringize]
+
+
+
@@ -0,0 +1,52 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+#include <boost/lexical_cast.hpp>
+#include <string>
+#include <cstdio>
+
+//[lexical_cast_log_errno
+//`The following example uses numeric data in a string expression: 
+
+void log_message(const std::string &);
+
+void log_errno(int yoko)
+{
+    log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
+}
+
+//] [/lexical_cast_log_errno]
+
+
+//[lexical_cast_fixed_buffer
+//`The following example converts some number and puts it to file:
+
+void number_to_file(int number, FILE* file)
+{
+    typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it
+    buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation
+    fputs(buffer.begin(), file);
+}
+
+//] [/lexical_cast_fixed_buffer]
+
+//[lexical_cast_substring_conversion
+//`The following example takes part of the string and converts it to `int`:
+
+int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n)
+{
+    return boost::lexical_cast<int>(s.data() + pos, n);
+}
+
+//] [/lexical_cast_substring_conversion]
+
+void log_message(const std::string &) {}
+
+int main()
+{
+    return 0;
+}
+
@@ -0,0 +1,39 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+
+//[lexical_cast_variant_to_long_double
+/*`
+    In this example we'll make a `to_long_double` method that converts value of the Boost.Variant to `long double`.
+*/
+
+#include <boost/lexical_cast.hpp>
+#include <boost/variant.hpp>
+#include <cassert>
+
+struct to_long_double_functor: boost::static_visitor<long double> {
+    template <class T>
+    long double operator()(const T& v) const {
+        // Lexical cast has many optimizations including optimizations for situations that usually 
+        // occur in generic programming, like std::string to std::string or arithmetic type to arithmetic type conversion. 
+        return boost::lexical_cast<long double>(v);
+    }
+};
+
+// Throws `boost::bad_lexical_cast` if value of the variant is not convertible to `long double`
+template <class Variant>
+long double to_long_double(const Variant& v) {
+    return boost::apply_visitor(to_long_double_functor(), v);
+}
+
+int main() {
+    boost::variant<char, int, std::string> v1('0'), v2("10.0001"), v3(1);
+
+    long double sum = to_long_double(v1) + to_long_double(v2) + to_long_double(v3);
+    assert(sum > 11 && sum < 11.1);
+}
+
+//] [/lexical_cast_variant_to_long_double]
@@ -1,17 +1,17 @@
 //  boost cast.hpp header file  ----------------------------------------------//

-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies. This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
+//  (C) Copyright Kevlin Henney and Dave Abrahams 1999.
+//  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)

-//  See http://www.boost.org for most recent version including documentation.
+//  See http://www.boost.org/libs/conversion for Documentation.

 //  Revision History
-//  02 Apr 01  Removed BOOST_NO_LIMITS workarounds and included 
-//             <boost/limits.hpp> instead (the workaround did not 
-//             actually compile when BOOST_NO_LIMITS was defined in 
+//  23 JUn 05  numeric_cast removed and redirected to the new verion (Fernando Cacciola)
+//  02 Apr 01  Removed BOOST_NO_LIMITS workarounds and included
+//             <boost/limits.hpp> instead (the workaround did not
+//             actually compile when BOOST_NO_LIMITS was defined in
 //             any case, so we loose nothing). (John Maddock)
 //  21 Jan 01  Undid a bug I introduced yesterday. numeric_cast<> never
 //             worked with stock GCC; trying to get it to do that broke
@@ -27,14 +27,14 @@
 //             (Dave Abrahams)
 //  30 Jun 00  More MSVC6 wordarounds.  See comments below.  (Dave Abrahams)
 //  28 Jun 00  Removed implicit_cast<>.  See comment below. (Beman Dawes)
-//  27 Jun 00  More MSVC6 workarounds 
+//  27 Jun 00  More MSVC6 workarounds
 //  15 Jun 00  Add workarounds for MSVC6
 //   2 Feb 00  Remove bad_numeric_cast ";" syntax error (Doncho Angelov)
 //  26 Jan 00  Add missing throw() to bad_numeric_cast::what(0 (Adam Levar)
 //  29 Dec 99  Change using declarations so usages in other namespaces work
 //             correctly (Dave Abrahams)
 //  23 Sep 99  Change polymorphic_downcast assert to also detect M.I. errors
-//             as suggested Darin Adler and improved by Valentin Bonnard.  
+//             as suggested Darin Adler and improved by Valentin Bonnard.
 //   2 Sep 99  Remove controversial asserts, simplify, rename.
 //  30 Aug 99  Move to cast.hpp, replace value_cast with numeric_cast,
 //             place in nested namespace.
@@ -44,21 +44,11 @@
 #define BOOST_CAST_HPP

 # include <boost/config.hpp>
-# include <cassert>
+# include <boost/assert.hpp>
 # include <typeinfo>
 # include <boost/type.hpp>
 # include <boost/limits.hpp>
-
-//  It has been demonstrated numerous times that MSVC 6.0 fails silently at link
-//  time if you use a template function which has template parameters that don't
-//  appear in the function's argument list.
-//
-//  TODO: Add this to config.hpp?
-# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // 1200 = VC6
-#  define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
-# else
-#  define BOOST_EXPLICIT_DEFAULT_TARGET
-# endif
+# include <boost/detail/select_type.hpp>

 namespace boost
 {
@@ -68,11 +58,11 @@ namespace boost
 //  polymorphic_cast  --------------------------------------------------------//

    //  Runtime checked polymorphic downcasts and crosscasts.
-    //  Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup, 
+    //  Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup,
    //  section 15.8 exercise 1, page 425.

    template <class Target, class Source>
-    inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
+    inline Target polymorphic_cast(Source* x)
    {
        Target tmp = dynamic_cast<Target>(x);
        if ( tmp == 0 ) throw std::bad_cast();
@@ -81,260 +71,24 @@ namespace boost

 //  polymorphic_downcast  ----------------------------------------------------//

-    //  assert() checked polymorphic downcast.  Crosscasts prohibited.
+    //  BOOST_ASSERT() checked polymorphic downcast.  Crosscasts prohibited.

-    //  WARNING: Because this cast uses assert(), it violates the One Definition
-    //  Rule if NDEBUG is inconsistently defined across translation units.
+    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
+    //  the One Definition Rule if used in multiple translation units
+    //  where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
+    //  NDEBUG are defined inconsistently.

    //  Contributed by Dave Abrahams

    template <class Target, class Source>
-    inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
+    inline Target polymorphic_downcast(Source* x)
    {
-        assert( dynamic_cast<Target>(x) == x );  // detect logic error
+        BOOST_ASSERT( dynamic_cast<Target>(x) == x );  // detect logic error
        return static_cast<Target>(x);
    }

-//  implicit_cast  -----------------------------------------------------------//
-//
-//  Removed due to uncertain purpose.  Use either numeric_cast (see below)
-//  or static_cast according to the need. 
-
-//  numeric_cast and related exception  --------------------------------------//
-
-//  Contributed by Kevlin Henney
-
-//  bad_numeric_cast  --------------------------------------------------------//
-
-    // exception used to indicate runtime numeric_cast failure
-    class bad_numeric_cast : public std::bad_cast
-    {
-    public:
-        // constructors, destructors and assignment operator defaulted
-
-        // function inlined for brevity and consistency with rest of library
-        virtual const char *what() const throw()
-        {
-            return "bad numeric cast: loss of range in numeric_cast";
-        }
-    };
-
-//  numeric_cast  ------------------------------------------------------------//
-
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-  
-    namespace detail
-    {
-       template <bool is_signed> struct numeric_min_select;
-    
-       template<>
-       struct numeric_min_select<true>
-       {
-         template <class T>
-         struct limits : std::numeric_limits<T>
-         {
-    	   static inline T min()
-# ifndef __GNUC__ // bug workaround courtesy Jens Maurer
-             {
-                 return std::numeric_limits<T>::min() >= 0
-                     // unary minus causes integral promotion, thus the static_cast<>
-                     ? static_cast<T>(-std::numeric_limits<T>::max())
-                     : std::numeric_limits<T>::min();
-             }
-# else
-                 ;
-# endif
-	       };
-       };
-
-# ifdef __GNUC__ // bug workaround courtesy Jens Maurer
-      template<> template<class T>
-      inline T numeric_min_select<true>::limits<T>::min()
-      {
-           return std::numeric_limits<T>::min() >= 0
-               // unary minus causes integral promotion, thus the static_cast<>
-               ? static_cast<T>(-std::numeric_limits<T>::max())
-               : std::numeric_limits<T>::min();
-      }
-# endif
-    
-      template<>
-      struct numeric_min_select<false>
-      {
-          template <class T>
-          struct limits : std::numeric_limits<T> {};
-      };
-      
-      // Move to namespace boost in utility.hpp?
-      template <class T>
-      struct fixed_numeric_limits
-          : public numeric_min_select<
-                       std::numeric_limits<T>::is_signed 
-                   >::template limits<T>
-      {
-      };
-    } // namespace detail
-  
-// less_than_type_min -
-  //    x_is_signed should be numeric_limits<X>::is_signed
-  //    y_is_signed should be numeric_limits<Y>::is_signed
-  //    y_min should be numeric_limits<Y>::min()
-  //
-  //    check(x, y_min) returns true iff x < y_min without invoking comparisons
-  //    between signed and unsigned values.
-  //
-  //    "poor man's partial specialization" is in use here.
-    template <bool x_is_signed, bool y_is_signed>
-    struct less_than_type_min
-    {
-        template <class X, class Y>
-        static bool check(X x, Y y_min)
-            { return x < y_min; }
-    };
-
-    template <>
-    struct less_than_type_min<false, true>
-    {
-        template <class X, class Y>
-        static bool check(X, Y)
-            { return false; }
-    };
-    
-    template <>
-    struct less_than_type_min<true, false>
-    {
-        template <class X, class Y>
-        static bool check(X x, Y)
-            { return x < 0; }
-    };
-    
-  // greater_than_type_max -
-  //    same_sign should be:
-  //            numeric_limits<X>::is_signed == numeric_limits<Y>::is_signed
-  //    y_max should be numeric_limits<Y>::max()
-  //
-  //    check(x, y_max) returns true iff x > y_max without invoking comparisons
-  //    between signed and unsigned values.
-  //
-  //    "poor man's partial specialization" is in use here.
-    template <bool same_sign, bool x_is_signed>
-    struct greater_than_type_max;
-
-    template<>
-    struct greater_than_type_max<true, true>
-    {
-        template <class X, class Y>
-        static inline bool check(X x, Y y_max)
-            { return x > y_max; }
-    };
-
-    template <>
-    struct greater_than_type_max<false, true>
-    {
-        // What does the standard say about this? I think it's right, and it
-        // will work with every compiler I know of.
-        template <class X, class Y>
-        static inline bool check(X x, Y)
-            { return x >= 0 && static_cast<X>(static_cast<Y>(x)) != x; }
-    };
-
-    template<>
-    struct greater_than_type_max<true, false>
-    {
-        template <class X, class Y>
-        static inline bool check(X x, Y y_max)
-            { return x > y_max; }
-    };
-
-    template <>
-    struct greater_than_type_max<false, false>
-    {
-        // What does the standard say about this? I think it's right, and it
-        // will work with every compiler I know of.
-        template <class X, class Y>
-        static inline bool check(X x, Y)
-            { return static_cast<X>(static_cast<Y>(x)) != x; }
-    };
-  
-#else // use #pragma hacks if available
-
-  namespace detail
-  {
-# if BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4018)
-#  pragma warning(disable : 4146)
-#elif defined(__BORLANDC__)
-#  pragma option push -w-8041
-# endif
-
-       // Move to namespace boost in utility.hpp?
-       template <class T>
-       struct fixed_numeric_limits : public std::numeric_limits<T>
-       {
-           static inline T min()
-           {
-               return std::numeric_limits<T>::is_signed && std::numeric_limits<T>::min() >= 0
-                   ? T(-std::numeric_limits<T>::max()) : std::numeric_limits<T>::min();
-           }
-       };
-  
-# if BOOST_MSVC
-#  pragma warning(pop)
-#elif defined(__BORLANDC__)
-#  pragma option pop
-# endif
-  } // namespace detail
-  
-#endif
-  
-    template<typename Target, typename Source>
-    inline Target numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET)
-    {
-        // typedefs abbreviating respective trait classes
-        typedef std::numeric_limits<Source> arg_traits;
-        typedef detail::fixed_numeric_limits<Target> result_traits;
-        
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-        // typedefs that act as compile time assertions
-        // (to be replaced by boost compile time assertions
-        // as and when they become available and are stable)
-        typedef bool argument_must_be_numeric[arg_traits::is_specialized];
-        typedef bool result_must_be_numeric[result_traits::is_specialized];
-
-        const bool arg_is_signed = arg_traits::is_signed;
-        const bool result_is_signed = result_traits::is_signed;
-        const bool same_sign = arg_is_signed == result_is_signed;
-
-        if (less_than_type_min<arg_is_signed, result_is_signed>::check(arg, result_traits::min())
-            || greater_than_type_max<same_sign, arg_is_signed>::check(arg, result_traits::max())
-            )
-            
-#else // We need to use #pragma hacks if available
-            
-# if BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4018)
-#elif defined(__BORLANDC__)
-#pragma option push -w-8012
-# endif
-        if ((arg < 0 && !result_traits::is_signed)  // loss of negative range
-             || (arg_traits::is_signed && arg < result_traits::min())  // underflow
-             || arg > result_traits::max())            // overflow
-# if BOOST_MSVC
-#  pragma warning(pop)
-#elif defined(__BORLANDC__)
-#pragma option pop
-# endif
-#endif
-        {
-            throw bad_numeric_cast();
-        }
-        return static_cast<Target>(arg);
-    } // numeric_cast
-
-#  undef BOOST_EXPLICIT_DEFAULT_TARGET
-
 } // namespace boost

+# include <boost/numeric/conversion/cast.hpp>
+
 #endif  // BOOST_CAST_HPP
@@ -0,0 +1,139 @@
+//-----------------------------------------------------------------------------
+// boost detail/templated_streams.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2013 John Maddock, 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)
+
+#ifndef BOOST_DETAIL_BASIC_POINTERBUF_HPP
+#define BOOST_DETAIL_BASIC_POINTERBUF_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include "boost/config.hpp"
+#include <streambuf>
+
+namespace boost { namespace detail {
+
+//
+// class basic_pointerbuf:
+// acts as a stream buffer which wraps around a pair of pointers:
+//
+template <class charT, class BufferT >
+class basic_pointerbuf : public BufferT {
+protected:
+   typedef BufferT base_type;
+   typedef basic_pointerbuf<charT, BufferT> this_type;
+   typedef typename base_type::int_type int_type;
+   typedef typename base_type::char_type char_type;
+   typedef typename base_type::pos_type pos_type;
+   typedef ::std::streamsize streamsize;
+   typedef typename base_type::off_type off_type;
+
+public:
+   basic_pointerbuf() : base_type() { setbuf(0, 0); }
+   const charT* getnext() { return this->gptr(); }
+
+#ifndef BOOST_NO_USING_TEMPLATE
+    using base_type::pptr;
+    using base_type::pbase;
+#else
+    charT* pptr() const { return base_type::pptr(); }
+    charT* pbase() const { return base_type::pbase(); }
+#endif
+
+protected:
+   // VC mistakenly assumes that `setbuf` and other functions are not referenced.
+   // Marking those functions with `inline` suppresses the warnings.
+   // There must be no harm from marking virtual functions as inline: inline virtual
+   // call can be inlined ONLY when the compiler knows the "exact class".
+   inline base_type* setbuf(char_type* s, streamsize n);
+   inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
+   inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
+
+private:
+   basic_pointerbuf& operator=(const basic_pointerbuf&);
+   basic_pointerbuf(const basic_pointerbuf&);
+};
+
+template<class charT, class BufferT>
+BufferT*
+basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
+{
+   this->setg(s, s, s + n);
+   return this;
+}
+
+template<class charT, class BufferT>
+typename basic_pointerbuf<charT, BufferT>::pos_type
+basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
+{
+   typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
+
+   if(which & ::std::ios_base::out)
+      return pos_type(off_type(-1));
+   std::ptrdiff_t size = this->egptr() - this->eback();
+   std::ptrdiff_t pos = this->gptr() - this->eback();
+   charT* g = this->eback();
+   switch(static_cast<cast_type>(way))
+   {
+   case ::std::ios_base::beg:
+      if((off < 0) || (off > size))
+         return pos_type(off_type(-1));
+      else
+         this->setg(g, g + off, g + size);
+      break;
+   case ::std::ios_base::end:
+      if((off < 0) || (off > size))
+         return pos_type(off_type(-1));
+      else
+         this->setg(g, g + size - off, g + size);
+      break;
+   case ::std::ios_base::cur:
+   {
+      std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
+      if((newpos < 0) || (newpos > size))
+         return pos_type(off_type(-1));
+      else
+         this->setg(g, g + newpos, g + size);
+      break;
+   }
+   default: ;
+   }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4244)
+#endif
+   return static_cast<pos_type>(this->gptr() - this->eback());
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+}
+
+template<class charT, class BufferT>
+typename basic_pointerbuf<charT, BufferT>::pos_type
+basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
+{
+   if(which & ::std::ios_base::out)
+      return pos_type(off_type(-1));
+   off_type size = static_cast<off_type>(this->egptr() - this->eback());
+   charT* g = this->eback();
+   if(off_type(sp) <= size)
+   {
+      this->setg(g, g + off_type(sp), g + size);
+   }
+   return pos_type(off_type(-1));
+}
+
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP
+
@@ -0,0 +1,184 @@
+// Copyright Alexander Nasonov & Paul A. Bristow 2006.
+
+// 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)
+
+#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+
+#include <climits>
+#include <ios>
+#include <limits>
+
+#include <boost/config.hpp>
+#include <boost/integer_traits.hpp>
+
+#ifndef BOOST_NO_IS_ABSTRACT
+// Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#endif
+
+#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
+  (defined(BOOST_MSVC) && (BOOST_MSVC<1310))
+
+#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#endif
+
+#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#include <boost/assert.hpp>
+#else
+#include <boost/static_assert.hpp>
+#endif
+
+namespace boost { namespace detail {
+
+class lcast_abstract_stub {};
+
+#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+// Calculate an argument to pass to std::ios_base::precision from
+// lexical_cast. See alternative implementation for broken standard
+// libraries in lcast_get_precision below. Keep them in sync, please.
+template<class T>
+struct lcast_precision
+{
+#ifdef BOOST_NO_IS_ABSTRACT
+    typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
+#else
+    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
+        boost::is_abstract<T>
+      , std::numeric_limits<lcast_abstract_stub>
+      , std::numeric_limits<T>
+      >::type limits;
+#endif
+
+    BOOST_STATIC_CONSTANT(bool, use_default_precision =
+            !limits::is_specialized || limits::is_exact
+        );
+
+    BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
+            !use_default_precision &&
+            limits::radix == 2 && limits::digits > 0
+        );
+
+    BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
+            !use_default_precision &&
+            limits::radix == 10 && limits::digits10 > 0
+        );
+
+    BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
+            boost::integer_traits<std::streamsize>::const_max
+        );
+
+    BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
+
+    BOOST_STATIC_ASSERT(!is_specialized_dec ||
+            precision_dec <= streamsize_max + 0UL
+        );
+
+    BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
+            2UL + limits::digits * 30103UL / 100000UL
+        );
+
+    BOOST_STATIC_ASSERT(!is_specialized_bin ||
+            (limits::digits + 0UL < ULONG_MAX / 30103UL &&
+            precision_bin > limits::digits10 + 0UL &&
+            precision_bin <= streamsize_max + 0UL)
+        );
+
+    BOOST_STATIC_CONSTANT(std::streamsize, value =
+            is_specialized_bin ? precision_bin
+                               : is_specialized_dec ? precision_dec : 6
+        );
+};
+#endif
+
+template<class T>
+inline std::streamsize lcast_get_precision(T* = 0)
+{
+#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+    return lcast_precision<T>::value;
+#else // Follow lcast_precision algorithm at run-time:
+
+#ifdef BOOST_NO_IS_ABSTRACT
+    typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
+#else
+    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
+        boost::is_abstract<T>
+      , std::numeric_limits<lcast_abstract_stub>
+      , std::numeric_limits<T>
+      >::type limits;
+#endif
+
+    bool const use_default_precision =
+        !limits::is_specialized || limits::is_exact;
+
+    if(!use_default_precision)
+    { // Includes all built-in floating-point types, float, double ...
+      // and UDT types for which digits (significand bits) is defined (not zero)
+
+        bool const is_specialized_bin =
+            limits::radix == 2 && limits::digits > 0;
+        bool const is_specialized_dec =
+            limits::radix == 10 && limits::digits10 > 0;
+        std::streamsize const streamsize_max =
+            (boost::integer_traits<std::streamsize>::max)();
+
+        if(is_specialized_bin)
+        { // Floating-point types with
+          // limits::digits defined by the specialization.
+
+            unsigned long const digits = limits::digits;
+            unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
+            // unsigned long is selected because it is at least 32-bits
+            // and thus ULONG_MAX / 30103UL is big enough for all types.
+            BOOST_ASSERT(
+                    digits < ULONG_MAX / 30103UL &&
+                    precision > limits::digits10 + 0UL &&
+                    precision <= streamsize_max + 0UL
+                );
+            return precision;
+        }
+        else if(is_specialized_dec)
+        {   // Decimal Floating-point type, most likely a User Defined Type
+            // rather than a real floating-point hardware type.
+            unsigned int const precision = limits::digits10 + 1U;
+            BOOST_ASSERT(precision <= streamsize_max + 0UL);
+            return precision;
+        }
+    }
+
+    // Integral type (for which precision has no effect)
+    // or type T for which limits is NOT specialized,
+    // so assume stream precision remains the default 6 decimal digits.
+    // Warning: if your User-defined Floating-point type T is NOT specialized,
+    // then you may lose accuracy by only using 6 decimal digits.
+    // To avoid this, you need to specialize T with either
+    // radix == 2 and digits == the number of significand bits,
+    // OR
+    // radix = 10 and digits10 == the number of decimal digits.
+
+    return 6;
+#endif
+}
+
+template<class T>
+inline void lcast_set_precision(std::ios_base& stream, T*)
+{
+    stream.precision(lcast_get_precision<T>());
+}
+
+template<class Source, class Target>
+inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
+{
+    std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
+    std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
+    stream.precision(s > t ? s : t);
+}
+
+}}
+
+#endif //  BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+
@@ -0,0 +1,29 @@
+// Copyright David Abrahams 2003.
+// 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)
+#ifndef IMPLICIT_CAST_DWA200356_HPP
+# define IMPLICIT_CAST_DWA200356_HPP
+
+# include <boost/mpl/identity.hpp>
+
+namespace boost {
+
+// implementation originally suggested by C. Green in
+// http://lists.boost.org/MailArchives/boost/msg00886.php
+
+// The use of identity creates a non-deduced form, so that the
+// explicit template argument must be supplied
+template <typename T>
+inline T implicit_cast (typename mpl::identity<T>::type x) {
+    return x;
+}
+
+// incomplete return type now is here
+//template <typename T>
+//void implicit_cast (...);
+
+} // namespace boost
+
+
+#endif // IMPLICIT_CAST_DWA200356_HPP
@@ -3,14 +3,21 @@
 <head>
 <meta http-equiv="Content-Language" content="en-us">
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Boost Conversion Library</title>
+<style>
+   .copyright
+    {
+        color: #666666;
+        font-size: small;
+    }
+</style>
 </head>

 <body bgcolor="#FFFFFF" text="#000000">

-<h1><img border="0" src="../../c++boost.gif" align="center" width="277" height="86">Boost
+<h1><img border="0" src="../../boost.png" align="center" width="277" height="86">Boost
 Conversion Library</h1>

 <p>The Conversion Library improves program safety and clarity by performing
@@ -22,18 +29,21 @@ supplied by several headers:</p>
 <ul>
  <li>The <a href="cast.htm">boost/cast</a> header provides <b>polymorphic_cast&lt;&gt;</b>
    and <b>polymorphic_downcast&lt;&gt;</b> to perform safe casting between
-    polymorphic types, and <b> numeric_cast</b><i>&lt;&gt;</i> to perform safe casting
-    between numeric types.<br>
+  polymorphic types.<br>
  </li>
-  <li>The <a href="lexical_cast.htm">boost/lexical_cast</a> header provides <b>lexical_cast&lt;&gt;</b>
+  <li>The <a href="../../doc/html/boost_lexical_cast.html">boost/lexical_cast</a> header provides <b>lexical_cast&lt;&gt;</b>
    general literal text conversions, such as an <code>int</code> represented as
    a <code>string</code>, or vice-versa.</li>
 </ul>
 <hr>
 <p>Revised <!--webbot bot="Timestamp" S-Type="EDITED"
-S-Format="%d %B, %Y" startspan -->06 January, 2001<!--webbot bot="Timestamp" endspan i-checksum="38320" -->
+S-Format="%d %B, %Y" startspan -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348" -->
+</p>
+<p class="copyright">
+    Copyright 2001 Beman Dawes.
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
 </p>
-
 </body>

 </html>
@@ -1,242 +1,16 @@
-<!doctype html public "-//W3C//DTD HTML Transitional 4.0//EN">
+
+<!--
+Copyright 2005-2007 Daniel James.
+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)
+-->
+
 <html>
 <head>
-    <title>lexical_cast</title>
-    <meta name="author" content="Kevlin Henney, mailto:kevlin@curbralan.com">
-    <meta name="generator" content="Microsoft FrontPage 4.0">
+    <meta http-equiv="refresh" content="0; URL=../../doc/html/boost_lexical_cast.html">
 </head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
-<a href="../../boost/lexical_cast.hpp">boost/lexical_cast.hpp</a></h1>
-
-<ul>
-    <li><a href="#motivation">Motivation</li>
-    <li></a><a href="#examples">Examples</li>
-    <li></a><a href="#synopsis">Synopsis</li>
-    <li></a><a href="#lexical_cast"><code>lexical_cast</code></li>
-    <li></a><a href="#bad_lexical_cast"><code>bad_lexical_cast</code></li>
-    <li></a><a href="#portability">Portability</li>
-    <li></a><a href="#future">Future directions</li>
-</ul>
-
-<hr>
-<h2><a name="motivation">Motivation</a></h2>
-
-Sometimes a value must be converted to a literal text form, such as an
-<code>int</code> represented as a <code>string</code>, or vice-versa, when
-a <code>string</code> is interpreted as an <code>int</code>. Such examples
-are common when converting between data types internal to a program and
-representation external to a program, such as windows and configuration files.
-<p>
-The standard C and C++ libraries offer a number of facilities for performing
-such conversions. However, they vary with their ease of use, extensibility,
-and safety.
-<p>
-For instance, there are a number of limitations with the family of standard C
-functions typified by <code>atoi</code>:
-<ul>
-	<li>
-	    Conversion is supported in one direction only: from text to
-		internal data type. Converting the other way using the C library
-		requires either the inconvenience and compromised safety of the
-		<code>sprintf</code> function, or the loss of portability associated
-		with non-standard functions such as <code>itoa</code>.
-	</li>
-	<li>
-	    The range of types supported is only a subset of the built-in numeric
-	    types, namely <code>int</code>, <code>long</code>,
-		and <code>double</code>.
-	</li>
-	<li>
-	    The range of types cannot be extended in a uniform manner. For
-	    instance, conversion from string representation to
-		<code>complex</code> or <code>rational</code>.
-	</li>
-</ul>
-The standard C functions typified by <code>strtol</code> have the same basic
-limitations, but offer finer control over the conversion process. However, for
-the common case such control is often either not required or not used. The
-<code>scanf</code> family of functions offer even greater control, but also
-lack safety and ease of use.
-<p>
-The standard C++ library offers <code>stringstream</code> for the kind of
-in-core formatting being discussed. It offers a great deal of control over the
-formatting and conversion of I/O to and from arbitrary types through text.
-However, for simple conversions direct use of <code>stringstream</code> can be
-either clumsy (with the introduction of extra local variables and the loss of
-infix-expression convenience) or obscure (where <code>stringstream</code>
-objects are created as temporary objects in an expression). Facets provide a
-comprehensive concept and facility for controlling textual representation, but
-their relatively high entry level requires an extreme degree of involvement
-for simple conversions.
-<p>
-The <code>lexical_cast</code> template function offers a convenient and consistent
-form for supporting common conversions to and from arbitrary types when they are
-represented as text. The simplification it offers is in expression-level
-convenience for such conversions. For more involved conversions, such as where
-precision or formatting need tighter control than is offered by the default
-behavior of <code>lexical_cast</code>, the conventional
-<code>stringstream</code> approach is recommended. Where the conversions are
-numeric to numeric, <code><a href="cast.htm#numeric_cast">numeric_cast</a></code> may offer more reasonable
-behavior than <code>lexical_cast</code>.
-<p>
-
-<hr>
-<h2><a name="examples">Examples</a></h2>
-
-The following example treats command line arguments as a sequence of numeric data:
-<blockquote>
-<pre>
-int main(int argc, char * argv[])
-{
-    using boost::lexical_cast;
-    using boost::bad_lexical_cast;
-
-    std::vector&lt;short&gt; args;
-
-    while(*++argv)
-    {
-        try
-        {
-            args.push_back(lexical_cast&lt;short&gt;(*argv));
-        }
-        catch(bad_lexical_cast &amp;)
-        {
-            args.push_back(0);
-        }
-    }
-    ...
-}
-</pre>
-</blockquote>
-
-The following example uses numeric data in a string expression:
-<blockquote>
-<pre>
-void log_message(const std::string &amp;);
-
-void log_errno(int yoko)
-{
-    log_message(&quot;Error &quot; + boost::lexical_cast&lt;std::string&gt;(yoko) + &quot;: &quot; + strerror(yoko));
-}
-</pre>
-</blockquote>
-
-<hr>
-<h2><a name="synopsis">Synopsis</a></h2>
-
-Library features defined in <a href="../../boost/lexical_cast.hpp"><code>&quot;boost/lexical_cast.hpp&quot;</code></a>:
-
-<blockquote>
-<pre>
-namespace boost
-{
-    class <a href="#bad_lexical_cast">bad_lexical_cast</a>;
-    template&lt;typename Target, typename Source&gt;
-      Target <a href="#lexical_cast">lexical_cast</a>(Source arg);
-}
-</pre>
-</blockquote>
-
-Test harness defined in <a href="lexical_cast_test.cpp"><code>&quot;lexical_cast_test.cpp&quot;</code></a>.
-<p>
-
-<hr>
-<h2><a name="lexical_cast"><code>lexical_cast</code></a></h2>
-
-<blockquote>
-<pre>
-template&lt;typename Target, typename Source&gt;
-  Target lexical_cast(Source arg);
-</pre>
-</blockquote>
-
-Returns the result of streaming <code>arg</code> into a <code>std::stringstream</code> and then
-out as a <code>Target</code> object. The conversion is parameterized by the current
-<a href="#lexical_context"><code>lexical_context</code></a>, if set. If the conversion is
-unsuccessful, a <a href="#bad_lexical_cast"><code>bad_lexical_cast</code></a> exception is thrown
-if the current <a href="#lexical_context"><code>lexical_context</code></a> is set for throwing or
-if there is no current <a href="#lexical_context"><code>lexical_context</code></a> set, otherwise a
-<code>Target()</code> is returned.
-<p>
-The requirements on the argument and result types are:
-<ul>
-	<li>
-	    <code>Source</code> is <i>OutputStreamable</i>, meaning that an
-	    <code>operator&lt;&lt;</code> is defined that takes a
-		<code>std::ostream</code> object on the left hand side and an instance
-		of the argument type on the right.
-	</li>
-	<li>
-	    Both <code>Source</code> and <code>Target</code> are <i>CopyConstructible</i> [20.1.3].
-	</li>
-	<li>
-	    <code>Target</code> is <i>InputStreamable</i>, meaning that an
-	    <code>operator&gt;&gt;</code> is defined that takes a
-		<code>std::istream</code> object on the left hand side and an instance
-		of the result type on the right.
-	</li>
-	<li>
-	    <code>Target</code> is <i>DefaultConstructible</i>, meaning that it is
-	    possible to	<i>default-initialize</i> an object of that type [8.5, 20.1.3].
-	</li>
-	<li>
-	    <code>Target</code> is <i>Assignable</i> [23.1].
-	</li>
-</ul>
-<p>
-
-<hr>
-<h2><a name="bad_lexical_cast"><code>bad_lexical_cast</code></a></h2>
-
-<blockquote>
-<pre>
-class bad_lexical_cast : public std::bad_cast
-{
-public:
-    virtual const char * what() const throw();
-};
-</pre>
-</blockquote>
-
-Exception used to indicate runtime <a href="#lexical_cast"><code>lexical_cast</code></a> failure.
-<p>
-
-<hr>
-<h2><a name="portability">Portability</a></h2>
-
-To date the code and test harness have been compiled successfully using
-Microsoft Visual C++ 6.0, Borland C++ 5.5, and GNU g++ 2.91. Tests have run successfully for
-Microsoft Visual C++ 6.0 and Borland C++ 5.5. For g++ streams interpret any integer, rather than
-just <code>0</code> and <code>1</code>, as valid for <code>bool</code>; the other tests pass
-without problem. The deprecated standard header <code>&lt;strstream&gt;</code> is used in
-preference to the standard <code>&lt;sstream&gt;</code> header for out-of-the-box g++ support.
-<p>
-
-<hr>
-<h2><a name="future">Future directions</a></h2>
-
-<ul>
-    <li>
-        A mechanism for providing quality-of-service control is needed, e.g. formatting and exception
-        behavior. In the name of simplicity (and release), the current version strips out an earlier
-        experimental version.
-    </li>
-    <li>
-        Wide character and incompatible <code>std::basic_string</code> issues need to be catered for.
-    </li>
-    <li>
-        An <code>interpret_cast</code> that performs a <i>do-something-reasonable</i> conversion between
-        types. It would, for instance, select between <code>numeric_cast</code> and <code>lexical_cast</code>
-        based on <code>std::numeric_limits<>::is_specialized</code>.
-    </li>
-</ul>
-
-<hr>
-
-<div align="right"><small><i>&copy; Copyright Kevlin Henney, 2000</i></small></div>
-
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/boost_lexical_cast.html">../../doc/html/boost_lexical_cast.html</a>
 </body>
 </html>
@@ -1,149 +0,0 @@
-//  boost lexical_cast_test.cpp program  -------------------------------------//
-
-//  See http://www.boost.org for most recent version including documentation.
-
-// what:  lexical_cast custom keyword cast tests
-// who:   contributed by Kevlin Henney
-// when:  October 2000
-// where: tested with MSVC 6.0 and BCC 5.5
-
-#include <boost/lexical_cast.hpp>
-#include "test.hpp"
-#include <complex>
-#include <iostream>
-#include <string>
-
-using namespace boost;
-using namespace std;
-
-typedef test::test<const char *, void (*)()> test_case;
-typedef const test_case * test_case_iterator;
-
-extern const test_case_iterator begin, end;
-
-int main()
-{
-    test::tester<test_case_iterator> test_suite(begin, end);
-    return test_suite() ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
-void test_to_string()
-{
-    test::check_equal(
-        lexical_cast<string>(2001), "2001",
-        "2001 -> \"2001\"");
-    test::check_equal(
-        lexical_cast<string>(2001.0), "2001",
-        "2001.0 ->\"2001\"");
-    test::check_equal(
-        lexical_cast<string>(complex<double>(2000,1)), "(2000,1)",
-        "complex<double>(2000,1) -> \"(2000,1)\"");
-}
-
-void test_to_int()
-{
-    test::check_equal(
-        lexical_cast<int>("2001"), 2001,
-        "\"2001\" -> 2001");
-    test::check_equal(
-        lexical_cast<int>("    2001"), 2001,
-        "\"    2001\" -> 2001");
-    test::check_equal(
-        lexical_cast<int>("2001    "), 2001,
-        "\"2001    \" -> 2001");
-    TEST_CHECK_THROW(
-        lexical_cast<int>("Two thousand and one"),
-        bad_lexical_cast,
-        "\"Two thousand and one\"");
-    TEST_CHECK_THROW(
-        lexical_cast<int>("2001: A Space Odyssey"),
-        bad_lexical_cast,
-        "\"2001: A Space Odyssey\"");
-    TEST_CHECK_THROW(
-        lexical_cast<int>(200.1),
-        bad_lexical_cast,
-        "200.1");
-    TEST_CHECK_THROW(
-        lexical_cast<int>("200e1"),
-        bad_lexical_cast,
-        "\"200e1\"");
-}
-
-void test_to_char()
-{
-    test::check_equal(
-        lexical_cast<char>("2"), '2',
-        "\"2\" -> '2'");
-    test::check_equal(
-        lexical_cast<char>("    2"), '2',
-        "\"    2\" -> '2'");
-    test::check_equal(
-        lexical_cast<char>("2    "), '2',
-        "\"2    \" -> '2'");
-    test::check_equal(
-        lexical_cast<char>(2), '2',
-        "2 -> '2'");
-    TEST_CHECK_THROW(
-        lexical_cast<char>("2001"),
-        bad_lexical_cast,
-        "\"2001\"");
-    TEST_CHECK_THROW(
-        lexical_cast<char>(2001),
-        bad_lexical_cast,
-        "2001");
-}
-
-void test_to_double()
-{
-    test::check_equal(
-        lexical_cast<double>("1e6"), 1e6,
-        "\"1e6\" -> 1e6");
-    test::check_equal(
-        lexical_cast<double>("1e-2"), 1e-2,
-        "\"1e-2\" -> 1e-2");
-}
-
-void test_to_bool()
-{
-    test::check_equal(
-        lexical_cast<bool>(1), true,
-        "1 -> true");
-    test::check_equal(
-        lexical_cast<bool>('0'), false,
-        "'0' -> false");
-    TEST_CHECK_THROW(
-        lexical_cast<bool>(2001),
-        bad_lexical_cast,
-        "2001");
-    TEST_CHECK_THROW(
-        lexical_cast<bool>(2),
-        bad_lexical_cast,
-        "2");
-    TEST_CHECK_THROW(
-        lexical_cast<bool>("true thousand and one"),
-        bad_lexical_cast,
-        "\"true thousand and one\"");
-}
-
-const test_case test_cases[] =
-{
-    { "lexical_cast<std::string>", test_to_string },
-    { "lexical_cast<int>",         test_to_int    },
-    { "lexical_cast<char>",        test_to_char   },
-    { "lexical_cast<double>",      test_to_double },
-    { "lexical_cast<bool>",        test_to_bool   }
-};
-
-const test_case_iterator begin = test_cases;
-const test_case_iterator end =
-    test_cases + (sizeof test_cases / sizeof *test_cases);
-
-// Copyright Kevlin Henney, 2000. All rights reserved.
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose is hereby granted without fee, provided that this copyright and
-// permissions notice appear in all copies and derivatives, and that no
-// charge may be made for the software and its documentation except to cover
-// cost of distribution.
-//
-// This software is provided "as is" without express or implied warranty.
@@ -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) ;
+
@@ -0,0 +1,369 @@
+//  (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 <cstring>
+#include <boost/container/string.hpp>
+
+// File to output data
+std::fstream fout;
+
+namespace boost {
+inline std::istream& operator>> (std::istream& in, boost::array<char,50>& res) {
+    in >> res.begin();
+    return in;
+}
+}
+
+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 CharT, std::size_t N>
+static inline void test_ss_constr(const boost::array<CharT, N>& in_val) {
+    OutT out_val;
+    std::stringstream ss;
+    ss << in_val.begin();
+    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 CharT, std::size_t N>
+static inline void test_ss_noconstr(StringStreamT& ss, const boost::array<CharT, N>& in_val) {
+    OutT out_val;
+    ss << in_val.begin(); // 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();
+}
+
+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 CharT, std::size_t N>
+    static inline void test(BufferT* /*buffer*/, const boost::array<CharT, N>& in_val, const char* const conv) {
+        OutT out_val;
+        sscanf(in_val.cbegin(), conv, &out_val);
+    }
+
+    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);
+    }
+
+    template <class OutT, class BufferT>
+    static inline void test(BufferT* /*buffer*/, const boost::iterator_range<const char*>& in_val, const char* const conv) {
+        OutT out_val;
+        sscanf(in_val.begin(), 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<boost::array<char, 50>, ssc_t>(from + "->array<char, 50>", conv("1.123"), "%s");
+
+    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);
+    }
+};
+
+struct to_iterator_range {
+    boost::iterator_range<const char*>  operator()(const char* const c) const {
+        return boost::make_iterator_range(c, c + std::strlen(c));
+    }
+};
+
+struct to_array_50 {
+    boost::array<char, 50> operator()(const char* const c) const {
+        boost::array<char, 50> ret;
+        std::strcpy(ret.begin(), c);
+        return ret;
+    }
+};
+
+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*");
+    string_like_test_set<to_iterator_range>("iterator_range<char*>");
+    string_like_test_set<to_array_50>("array<char, 50>");
+
+    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;
+}
+
+
@@ -1,312 +0,0 @@
-// what:  simple unit test framework
-// who:   developed by Kevlin Henney
-// when:  November 2000
-// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.91
-//
-// ChangeLog:
-//      20 Jan 2001 - Fixed a warning for MSVC (Dave Abrahams)
-
-#ifndef TEST_INCLUDED
-#define TEST_INCLUDED
-
-#include <exception>
-#include <iostream>
-#include <strstream> // for out-of-the-box g++
-#include <string>
-
-namespace test // test tuple comprises name and nullary function (object)
-{
-    template<typename string_type, typename function_type>
-    struct test
-    {
-        string_type   name;
-        function_type action;
-
-        static test make(string_type name, function_type action)
-        {
-            test result; // MSVC aggreggate initializer bugs
-            result.name   = name;
-            result.action = action;
-            return result;
-        }
-    };
-}
-
-namespace test // failure exception used to indicate checked test failures
-{
-    class failure : public std::exception
-    {
-    public: // struction (default cases are OK)
-
-        failure(const std::string & why)
-          : reason(why)
-        {
-        }
-
-        // std::~string has no exception-specification (could throw anything),
-	// but we need to be compatible with std::~exception's empty one
-        // see std::15.4p13 and std::15.4p3
-        ~failure() throw()
-        {
-        }
-
-    public: // usage
-
-        virtual const char * what() const throw()
-        {
-            return reason.c_str();
-        }
-
-    private: // representation
-
-        std::string reason;
-
-    };
-}
-
-namespace test // not_implemented exception used to mark unimplemented tests
-{
-    class not_implemented : public std::exception
-    {
-    public: // usage (default ctor and dtor are OK)
-
-        virtual const char * what() const throw()
-        {
-            return "not implemented";
-        }
-
-    };
-}
-
-namespace test // test utilities
-{
-    inline void check(bool condition, const std::string & description)
-    {
-        if(!condition)
-        {
-            throw failure(description);
-        }
-    }
-
-    inline void check_true(bool value, const std::string & description)
-    {
-        check(value, "expected true: " + description);
-    }
-
-    inline void check_false(bool value, const std::string & description)
-    {
-        check(!value, "expected false: " + description);
-    }
-
-    template<typename lhs_type, typename rhs_type>
-    void check_equal(
-        const lhs_type & lhs, const rhs_type & rhs,
-        const std::string & description)
-    {
-        check(lhs == rhs, "expected equal values: " + description);
-    }
-
-    template<typename lhs_type, typename rhs_type>
-    void check_unequal(
-        const lhs_type & lhs, const rhs_type & rhs,
-        const std::string & description)
-    {
-        check(lhs != rhs, "expected unequal values: " + description);
-    }
-
-    inline void check_null(const void* ptr, const std::string & description)
-    {
-        check(!ptr, "expected null pointer: " + description);
-    }
-
-    inline void check_non_null(const void* ptr, const std::string & description)
-    {
-        check(ptr != 0, "expected non-null pointer: " + description);
-    }
-}
-
-#define TEST_CHECK_THROW(expression, exception, description) \
-    try \
-    { \
-        expression; \
-        throw ::test::failure(description); \
-    } \
-    catch(exception &) \
-    { \
-    }
-
-namespace test // memory tracking (enabled if test new and delete linked in)
-{
-    class allocations
-    {
-    public: // singleton access
-
-        static allocations & instance()
-        {
-            static allocations singleton;
-            return singleton;
-        }
-
-    public: // logging
-
-        void clear()
-        {
-            alloc_count = dealloc_count = 0;
-        }
-
-        void allocation()
-        {
-            ++alloc_count;
-        }
-
-        void deallocation()
-        {
-            ++dealloc_count;
-        }
-
-    public: // reporting
-
-        unsigned long allocated() const
-        {
-            return alloc_count;
-        }
-
-        unsigned long deallocated() const
-        {
-            return dealloc_count;
-        }
-
-        bool balanced() const
-        {
-            return alloc_count == dealloc_count;
-        }
-
-    private: // structors (default dtor is fine)
-    
-        allocations()
-          : alloc_count(0), dealloc_count(0)
-        {
-        }
-
-    private: // prevention
-
-        allocations(const allocations &);
-        allocations & operator=(const allocations &);
-
-    private: // state
-
-        unsigned long alloc_count, dealloc_count;
-
-    };
-}
-
-namespace test // tester is the driver class for a sequence of tests
-{
-    template<typename test_iterator>
-    class tester
-    {
-    public: // structors (default destructor is OK)
-
-        tester(test_iterator first_test, test_iterator after_last_test)
-          : begin(first_test), end(after_last_test)
-        {
-        }
-
-    public: // usage
-
-        bool operator()(); // returns true if all tests passed
-
-    private: // representation
-
-        test_iterator begin, end;
-
-    private: // prevention
-
-        tester(const tester &);
-        tester &operator=(const tester &);
-
-    };
-
-    template<typename test_iterator>
-    bool tester<test_iterator>::operator()()
-    {
-        using namespace std;
-
-        unsigned long passed = 0, failed = 0, unimplemented = 0;
-
-        for(test_iterator current = begin; current != end; ++current)
-        {
-            cerr << "[" << current->name << "] " << flush;
-            string result = "passed"; // optimistic
-
-            try
-            {
-                allocations::instance().clear();
-                current->action();
-
-                if(!allocations::instance().balanced())
-                {
-                    unsigned long allocated   = allocations::instance().allocated();
-                    unsigned long deallocated = allocations::instance().deallocated();
-                    ostrstream report;
-                    report << "new/delete ("
-                           << allocated << " allocated, "
-                           << deallocated << " deallocated)"
-                           << ends;
-                    const char * text = report.str();
-                    report.freeze(false);
-                    throw failure(text);
-                }
-
-                ++passed;
-            }
-            catch(const failure & caught)
-            {
-                (result = "failed: ") += caught.what();
-                ++failed;
-            }
-            catch(const not_implemented &)
-            {
-                result = "not implemented";
-                ++unimplemented;
-            }
-            catch(const exception & caught)
-            {
-                (result = "exception: ") += caught.what();
-                ++failed;
-            }
-            catch(...)
-            {
-                result = "failed with unknown exception";
-                ++failed;
-            }
-
-            cerr << result << endl;
-        }
-
-        cerr << passed + failed << " tests: "
-             << passed << " passed, "
-             << failed << " failed";
-
-        if(unimplemented)
-        {
-            cerr << " (" << unimplemented << " not implemented)";
-        }
-
-        cerr << endl;
-
-        return failed == 0;
-    }
-}
-
-#endif
-
-// Copyright Kevlin Henney, 2000. All rights reserved.
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose is hereby granted without fee, provided that this copyright and
-// permissions notice appear in all copies and derivatives, and that no
-// charge may be made for the software and its documentation except to cover
-// cost of distribution.
-//
-// This software is provided "as is" without express or implied warranty.
@@ -0,0 +1,73 @@
+# Copyright (C) 2001-2003 Douglas Gregor
+# Copyright (C) 2011-2013 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)
+#
+
+import testing ;
+import feature ;
+
+project
+    : requirements
+        <library>/boost/test//boost_unit_test_framework
+        <link>static
+        <toolset>gcc-4.7:<cxxflags>-ftrapv
+        <toolset>gcc-4.6:<cxxflags>-ftrapv
+        <toolset>clang:<cxxflags>-ftrapv
+        # default to all warnings on:
+        <warnings>all
+        # set warnings as errors for those compilers we know we get warning free:
+        <toolset>gcc:<cxxflags>-Wextra
+        <toolset>gcc:<cxxflags>-Wno-uninitialized
+    ;
+
+# Thanks to Steven Watanabe for helping with <nowchar> feature
+feature.feature nowchar : on :
+ composite optional propagated link-incompatible ;
+feature.compose <nowchar>on : <cxxflags>/Zc:wchar_t- ;
+
+test-suite conversion
+  : [ run implicit_cast.cpp ]
+    [ compile-fail implicit_cast_fail.cpp ]
+    [ run cast_test.cpp ]
+    [ run numeric_cast_test.cpp ]
+    [ run lexical_cast_test.cpp ]
+    [ run lexical_cast_loopback_test.cpp ]
+    [ run lexical_cast_abstract_test.cpp ]
+    [ run lexical_cast_noncopyable_test.cpp ]
+    [ run lexical_cast_vc8_bug_test.cpp ]
+    [ run lexical_cast_wchars_test.cpp ]
+    [ run lexical_cast_float_types_test.cpp ]
+    [ run lexical_cast_inf_nan_test.cpp ]
+    [ run lexical_cast_containers_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>clang:<cxxflags>-Wno-long-long ]
+    [ run lexical_cast_empty_input_test.cpp ]
+    [ run lexical_cast_pointers_test.cpp ]
+    [ compile lexical_cast_typedefed_wchar_test.cpp : <toolset>msvc:<nowchar>on ]
+    [ run lexical_cast_typedefed_wchar_test_runtime.cpp : : : <toolset>msvc:<nowchar>on <toolset>msvc,<stdlib>stlport:<build>no ]
+    [ run lexical_cast_no_locale_test.cpp : : : <define>BOOST_NO_STD_LOCALE <define>BOOST_LEXICAL_CAST_ASSUME_C_LOCALE ]
+    [ run lexical_cast_no_exceptions_test.cpp : : : <define>BOOST_NO_EXCEPTIONS
+      <toolset>gcc-4.3:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.4:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.5:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.6:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.7:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.8:<cxxflags>-fno-exceptions
+      <toolset>clang:<cxxflags>-fno-exceptions
+    ]
+    [ run lexical_cast_iterator_range_test.cpp ]
+    [ run lexical_cast_arrays_test.cpp ]
+    [ run lexical_cast_integral_types_test.cpp ]
+    [ run lexical_cast_stream_detection_test.cpp ]
+    [ run lexical_cast_stream_traits_test.cpp ]
+    [ compile-fail lexical_cast_to_pointer_test.cpp ]
+    [ run lexical_cast_filesystem_test.cpp ../../filesystem/build//boost_filesystem/<link>static ]
+  ;
+
+# Assuring that examples compile and run. Adding sources from `example` directory to the `conversion` test suite. 
+for local p in [ glob ../example/*.cpp ]
+{
+    conversion += [ run $(p) ] ;
+}
+
+
@@ -0,0 +1,91 @@
+//  boost utility cast test program  -----------------------------------------//
+
+//  (C) Copyright Beman Dawes, Dave Abrahams 1999. 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)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//   28 Set 04  factored out numeric_cast<> test (Fernando Cacciola)
+//   20 Jan 01  removed use of <limits> for portability to raw GCC (David Abrahams)
+//   28 Jun 00  implicit_cast removed (Beman Dawes)
+//   30 Aug 99  value_cast replaced by numeric_cast
+//    3 Aug 99  Initial Version
+
+#include <iostream>
+#include <climits>
+#include <cfloat>   // for DBL_MAX (Peter Schmid)
+#include <boost/cast.hpp>
+
+#  if SCHAR_MAX == LONG_MAX
+#      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
+#  endif
+
+using namespace boost;
+using std::cout;
+
+namespace
+{
+    struct Base
+    {
+        virtual char kind() { return 'B'; }
+    };
+
+    struct Base2
+    {
+        virtual char kind2() { return '2'; }
+    };
+
+    struct Derived : public Base, Base2
+    {
+        virtual char kind() { return 'D'; }
+    };
+}
+
+
+int main( int argc, char * argv[] )
+{
+#   ifdef NDEBUG
+        cout << "NDEBUG is defined\n";
+#   else
+        cout << "NDEBUG is not defined\n";
+#   endif
+
+    cout << "\nBeginning tests...\n";
+
+//  test polymorphic_cast  ---------------------------------------------------//
+
+    //  tests which should succeed
+    Base *    base = new Derived;
+    Base2 *   base2 = 0;
+    Derived * derived = 0;
+    derived = polymorphic_downcast<Derived*>( base );  // downcast
+    assert( derived->kind() == 'D' );
+
+    derived = 0;
+    derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
+    assert( derived->kind() == 'D' );
+
+    base2 = polymorphic_cast<Base2*>( base ); // crosscast
+    assert( base2->kind2() == '2' );
+
+     //  tests which should result in errors being detected
+    int err_count = 0;
+    base = new Base;
+
+    if ( argc > 1 && *argv[1] == '1' )
+        { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
+
+    bool caught_exception = false;
+    try { derived = polymorphic_cast<Derived*>( base ); }
+    catch (std::bad_cast)
+        { cout<<"caught bad_cast\n"; caught_exception = true; }
+    if ( !caught_exception ) ++err_count;
+    //  the following is just so generated code can be inspected
+    if ( derived->kind() == 'B' ) ++err_count;
+
+    cout << err_count << " errors detected\nTest "
+         << (err_count==0 ? "passed\n" : "failed\n");
+    return err_count;
+}   // main
@@ -0,0 +1,38 @@
+// Copyright David Abrahams 2003.
+// 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/implicit_cast.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/type.hpp>
+using boost::implicit_cast;
+using boost::type;
+
+template <class T>
+type<T> check_return(T) { return type<T>(); }
+
+struct foo
+{
+    foo(char const*) {}
+    operator long() const { return 0; }
+};
+
+typedef type<long> long_type;
+typedef type<foo> foo_type;
+
+int main()
+{
+    type<long> x = check_return(boost::implicit_cast<long>(1));
+    BOOST_TEST(boost::implicit_cast<long>(1) == 1L);
+
+    type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
+    type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
+
+    // warning supression:
+    (void)x;
+    (void)f;
+    (void)z;
+
+    return boost::report_errors();
+}
@@ -0,0 +1,26 @@
+// Copyright David Abrahams 2003.
+// 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/implicit_cast.hpp>
+#include <boost/type.hpp>
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+using boost::implicit_cast;
+
+struct foo
+{
+    explicit foo(char const*) {}
+};
+
+int test_main(int, char*[])
+{
+    foo x = implicit_cast<foo>("foobar");
+    (void)x;            // warning suppression.
+    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
+    return 0;
+}
+
@@ -0,0 +1,61 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Sergey Shandar 2005, Alexander Nasonov, 2007.
+//
+//  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 abstract class. Bug 1358600:
+// http://sf.net/tracker/?func=detail&aid=1358600&group_id=7586&atid=107586
+
+#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_abstract();
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test");
+    suite->add(BOOST_TEST_CASE(&test_abstract));
+
+    return suite;
+}
+
+class A
+{
+public:
+    virtual void out(std::ostream &) const = 0;
+};
+
+class B: public A
+{
+public:
+    virtual void out(std::ostream &O) const { O << "B"; }
+};
+
+std::ostream &operator<<(std::ostream &O, const A &a)
+{
+    a.out(O);
+    return O;
+}
+
+void test_abstract()
+{
+    const A &a = B();
+    BOOST_CHECK(boost::lexical_cast<std::string>(a) == "B");
+}
+
@@ -0,0 +1,377 @@
+//  Testing boost::lexical_cast with boost::container::string.
+//
+//  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/lexical_cast.hpp>
+
+#include <boost/test/unit_test.hpp>
+    
+#include <boost/array.hpp>
+
+void testing_boost_array_output_conversion();
+void testing_std_array_output_conversion();
+
+void testing_boost_array_input_conversion();
+void testing_std_array_input_conversion();
+
+using namespace boost;
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU16
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU32
+#endif
+
+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::array and std::array");
+
+    suite->add(BOOST_TEST_CASE(testing_boost_array_output_conversion));
+    suite->add(BOOST_TEST_CASE(testing_std_array_output_conversion));
+    suite->add(BOOST_TEST_CASE(testing_boost_array_input_conversion));
+    suite->add(BOOST_TEST_CASE(testing_std_array_input_conversion));
+
+    return suite;
+}
+
+template <template <class, std::size_t> class ArrayT, class T>
+static void testing_template_array_output_on_spec_value(T val) 
+{
+    typedef ArrayT<char, 300>             arr_type;
+    typedef ArrayT<char, 1>               short_arr_type;
+    typedef ArrayT<unsigned char, 300>    uarr_type;
+    typedef ArrayT<unsigned char, 1>      ushort_arr_type;
+    typedef ArrayT<signed char, 4>        sarr_type;
+    typedef ArrayT<signed char, 3>        sshort_arr_type;
+
+    std::string ethalon("100");
+    using namespace std;
+
+    {
+        arr_type res1 = lexical_cast<arr_type>(val);
+        BOOST_CHECK_EQUAL(&res1[0], ethalon);
+        const arr_type res2 = lexical_cast<arr_type>(val);
+        BOOST_CHECK_EQUAL(&res2[0], ethalon);
+        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
+    }
+    
+    {
+        uarr_type res1 = lexical_cast<uarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
+        const uarr_type res2 = lexical_cast<uarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
+    }
+    
+    {
+        sarr_type res1 = lexical_cast<sarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
+        const sarr_type res2 = lexical_cast<sarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
+    }
+
+#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
+    typedef ArrayT<wchar_t, 300> warr_type;
+    typedef ArrayT<wchar_t, 3> wshort_arr_type;
+    std::wstring wethalon(L"100");
+
+    {
+        warr_type res = lexical_cast<warr_type>(val);
+        BOOST_CHECK(&res[0] == wethalon);
+    }
+
+    {
+        const warr_type res = lexical_cast<warr_type>(val);
+        BOOST_CHECK(&res[0] == wethalon);
+    }
+    
+    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
+
+#endif
+
+#ifdef BOOST_LC_RUNU16
+    typedef ArrayT<char16_t, 300> u16arr_type;
+    typedef ArrayT<char16_t, 3> u16short_arr_type;
+    std::u16string u16ethalon(u"100");
+
+    {
+        u16arr_type res = lexical_cast<u16arr_type>(val);
+        BOOST_CHECK(&res[0] == u16ethalon);
+    }
+
+    {
+        const u16arr_type res = lexical_cast<u16arr_type>(val);
+        BOOST_CHECK(&res[0] == u16ethalon);
+    }
+    
+    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
+#endif
+
+#ifdef BOOST_LC_RUNU32
+    typedef ArrayT<char32_t, 300> u32arr_type;
+    typedef ArrayT<char32_t, 3> u32short_arr_type;
+    std::u32string u32ethalon(U"100");
+
+    {
+        u32arr_type res = lexical_cast<u32arr_type>(val);
+        BOOST_CHECK(&res[0] == u32ethalon);
+    }
+
+    {
+        const u32arr_type res = lexical_cast<u32arr_type>(val);
+        BOOST_CHECK(&res[0] == u32ethalon);
+    }
+    
+    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
+#endif
+}
+
+
+template <template <class, std::size_t> class ArrayT>
+static void testing_template_array_output_on_char_value() 
+{
+    typedef ArrayT<char, 300>             arr_type;
+    typedef ArrayT<char, 1>               short_arr_type;
+    typedef ArrayT<unsigned char, 300>    uarr_type;
+    typedef ArrayT<unsigned char, 1>      ushort_arr_type;
+    typedef ArrayT<signed char, 4>        sarr_type;
+    typedef ArrayT<signed char, 3>        sshort_arr_type;
+
+    const char val[] = "100";
+    std::string ethalon("100");
+    using namespace std;
+
+    {
+        arr_type res1 = lexical_cast<arr_type>(val);
+        BOOST_CHECK_EQUAL(&res1[0], ethalon);
+        const arr_type res2 = lexical_cast<arr_type>(val);
+        BOOST_CHECK_EQUAL(&res2[0], ethalon);
+        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
+    }
+    
+    {
+        uarr_type res1 = lexical_cast<uarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
+        const uarr_type res2 = lexical_cast<uarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
+    }
+    
+    {
+        sarr_type res1 = lexical_cast<sarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
+        const sarr_type res2 = lexical_cast<sarr_type>(val);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
+    }
+
+#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
+    typedef ArrayT<wchar_t, 4> warr_type;
+    typedef ArrayT<wchar_t, 3> wshort_arr_type;
+    std::wstring wethalon(L"100");
+
+    {
+        warr_type res = lexical_cast<warr_type>(val);
+        BOOST_CHECK(&res[0] == wethalon);
+        warr_type res3 = lexical_cast<warr_type>(wethalon);
+        BOOST_CHECK(&res3[0] == wethalon);
+    }
+
+    {
+        const warr_type res = lexical_cast<warr_type>(val);
+        BOOST_CHECK(&res[0] == wethalon);
+        const warr_type res3 = lexical_cast<warr_type>(wethalon);
+        BOOST_CHECK(&res3[0] == wethalon);
+    }
+    
+    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
+
+#endif
+
+#ifdef BOOST_LC_RUNU16
+    typedef ArrayT<char16_t, 300> u16arr_type;
+    typedef ArrayT<char16_t, 3> u16short_arr_type;
+    std::u16string u16ethalon(u"100");
+
+    {
+#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
+        u16arr_type res = lexical_cast<u16arr_type>(val);
+        BOOST_CHECK(&res[0] == u16ethalon);  
+#endif
+
+        u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
+        BOOST_CHECK(&res3[0] == u16ethalon);
+    }
+
+    {
+#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
+        const u16arr_type res = lexical_cast<u16arr_type>(val);
+        BOOST_CHECK(&res[0] == u16ethalon);
+#endif
+        const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
+        BOOST_CHECK(&res3[0] == u16ethalon);
+    }
+    
+    // Some compillers may throw std::bad_alloc here
+    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), std::exception); 
+#endif
+
+#ifdef BOOST_LC_RUNU32
+    typedef ArrayT<char32_t, 300> u32arr_type;
+    typedef ArrayT<char32_t, 3> u32short_arr_type;
+    std::u32string u32ethalon(U"100");
+
+    {
+#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
+        u32arr_type res = lexical_cast<u32arr_type>(val);
+        BOOST_CHECK(&res[0] == u32ethalon);
+#endif
+        u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
+        BOOST_CHECK(&res3[0] == u32ethalon);
+    }
+
+    {
+#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
+        const u32arr_type res = lexical_cast<u32arr_type>(val);
+        BOOST_CHECK(&res[0] == u32ethalon);
+#endif
+        const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
+        BOOST_CHECK(&res3[0] == u32ethalon);
+    }
+    
+    // Some compillers may throw std::bad_alloc here
+    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), std::exception);
+#endif
+}
+
+
+void testing_boost_array_output_conversion()
+{   
+    testing_template_array_output_on_char_value<boost::array>();
+    testing_template_array_output_on_spec_value<boost::array>(100);
+    testing_template_array_output_on_spec_value<boost::array>(static_cast<short>(100));
+    testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned short>(100));
+    testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned int>(100));
+}
+
+void testing_std_array_output_conversion()
+{
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+    testing_template_array_output_on_char_value<std::array>();
+    testing_template_array_output_on_spec_value<std::array>(100);
+    testing_template_array_output_on_spec_value<std::array>(static_cast<short>(100));
+    testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned short>(100));
+    testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned int>(100));
+#endif
+
+    BOOST_CHECK(true);
+}
+
+template <template <class, std::size_t> class ArrayT>
+static void testing_generic_array_input_conversion()
+{
+    {
+        ArrayT<char, 4> var_zero_terminated = {{ '1', '0', '0', '\0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated), "100");
+        BOOST_CHECK_EQUAL(lexical_cast<int>(var_zero_terminated), 100);
+
+        ArrayT<char, 3> var_none_terminated = {{ '1', '0', '0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated), "100");
+        BOOST_CHECK_EQUAL(lexical_cast<short>(var_none_terminated), static_cast<short>(100));
+
+        ArrayT<const char, 4> var_zero_terminated_const_char = {{ '1', '0', '0', '\0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_char), "100");
+
+        ArrayT<const char, 3> var_none_terminated_const_char = {{ '1', '0', '0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_char), "100");
+
+        const ArrayT<char, 4> var_zero_terminated_const_var = {{ '1', '0', '0', '\0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var), "100");
+
+        const ArrayT<char, 3> var_none_terminated_const_var = {{ '1', '0', '0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var), "100");
+
+        const ArrayT<const char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
+
+        const ArrayT<const char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
+        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
+    }
+
+    {
+        const ArrayT<const unsigned char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
+
+        const ArrayT<const unsigned char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
+    }
+
+    {
+        const ArrayT<const signed char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
+
+        const ArrayT<const signed char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
+        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
+        BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(var_none_terminated_const_var_const_char), 100u);
+    }
+
+
+#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
+    {
+        const ArrayT<const wchar_t, 4> var_zero_terminated_const_var_const_char = {{ L'1', L'0', L'0', L'\0'}}; 
+        BOOST_CHECK(lexical_cast<std::wstring>(var_zero_terminated_const_var_const_char) == L"100");
+
+        const ArrayT<const wchar_t, 3> var_none_terminated_const_var_const_char = {{ L'1', L'0', L'0'}}; 
+        BOOST_CHECK(lexical_cast<std::wstring>(var_none_terminated_const_var_const_char) == L"100");
+        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
+    }
+#endif
+
+#ifdef BOOST_LC_RUNU16
+    {
+        const ArrayT<const char16_t, 4> var_zero_terminated_const_var_const_char = {{ u'1', u'0', u'0', u'\0'}}; 
+        BOOST_CHECK(lexical_cast<std::u16string>(var_zero_terminated_const_var_const_char) == u"100");
+        BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(var_zero_terminated_const_var_const_char), static_cast<unsigned short>(100));
+
+        const ArrayT<const char16_t, 3> var_none_terminated_const_var_const_char = {{ u'1', u'0', u'0'}}; 
+        BOOST_CHECK(lexical_cast<std::u16string>(var_none_terminated_const_var_const_char) == u"100");
+    }
+#endif
+
+#ifdef BOOST_LC_RUNU32
+    {
+        const ArrayT<const char32_t, 4> var_zero_terminated_const_var_const_char = {{ U'1', U'0', U'0', U'\0'}}; 
+        BOOST_CHECK(lexical_cast<std::u32string>(var_zero_terminated_const_var_const_char) == U"100");
+
+        const ArrayT<const char32_t, 3> var_none_terminated_const_var_const_char = {{ U'1', U'0', U'0'}}; 
+        BOOST_CHECK(lexical_cast<std::u32string>(var_none_terminated_const_var_const_char) == U"100");
+        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
+    }
+#endif
+}
+
+void testing_boost_array_input_conversion()
+{
+    testing_generic_array_input_conversion<boost::array>();
+}
+
+void testing_std_array_input_conversion()
+{
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+    testing_generic_array_input_conversion<std::array>();
+#endif
+
+    BOOST_CHECK(true);
+}
+
@@ -0,0 +1,83 @@
+//  Testing boost::lexical_cast with boost::container::string.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011.
+//
+//  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/lexical_cast.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/container/string.hpp>
+
+void testing_boost_containers_basic_string();
+void testing_boost_containers_string_std_string();
+void testing_boost_containers_string_widening();
+
+
+using namespace boost;
+
+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));
+    suite->add(BOOST_TEST_CASE(testing_boost_containers_string_widening));
+
+    return suite;
+}
+
+void testing_boost_containers_basic_string()
+{
+    BOOST_CHECK("100" == lexical_cast<boost::container::string>("100"));
+    BOOST_CHECK(L"100" == lexical_cast<boost::container::wstring>(L"100"));
+
+    BOOST_CHECK("100" == lexical_cast<boost::container::string>(100));
+    boost::container::string str("1000");
+    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
+
+}
+
+void testing_boost_containers_string_widening()
+{
+    const char char_array[] = "Test string";
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    const wchar_t wchar_array[] = L"Test string";
+    BOOST_CHECK(boost::lexical_cast<boost::container::wstring>(char_array) == wchar_array);
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+    const char16_t char16_array[] = u"Test string";
+    BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char16_t> >(char_array) == char16_array);
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+    const char32_t char32_array[] = U"Test string";
+    BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char32_t> >(char_array) == char32_array);
+#endif
+}
@@ -0,0 +1,167 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011.
+//
+//  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;
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#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);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
+#endif
+    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_iterator_range()
+{
+
+    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_string()
+{
+    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);
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    std::wstring vw;
+    do_test_on_empty_input(vw);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(vw), bad_lexical_cast);
+#endif
+
+// Currently, no compiler and STL library fully support char16_t and char32_t
+//#ifndef BOOST_NO_CXX11_CHAR16_T
+//    std::basic_string<char16_t> v16w;
+//    do_test_on_empty_input(v16w);
+//    BOOST_CHECK_THROW(lexical_cast<char16_t>(v16w), bad_lexical_cast);
+//#endif
+//#ifndef BOOST_NO_CXX11_CHAR32_T
+//    std::basic_string<char32_t> v32w;
+//    do_test_on_empty_input(v32w);
+//    BOOST_CHECK_THROW(lexical_cast<char32_t>(v32w), bad_lexical_cast);
+//#endif
+}
+
+struct 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_;
+}
+
+void test_empty_user_class()
+{
+    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);
+}
+
+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_vector()
+{
+    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_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 =
+        BOOST_TEST_SUITE("lexical_cast. Empty input unit test");
+    suite->add(BOOST_TEST_CASE(&test_empty_iterator_range));
+    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;
+}
@@ -0,0 +1,46 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013.
+//
+//  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 lexical_cast usage with long filesystem::path. Bug 7704.
+
+#include <boost/config.hpp>
+
+#include <boost/test/unit_test.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/filesystem/path.hpp>
+
+using namespace boost;
+
+void test_filesystem();
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test");
+    suite->add(BOOST_TEST_CASE(&test_filesystem));
+
+    return suite;
+}
+
+void test_filesystem()
+{
+    boost::filesystem::path p;
+    std::string s1 = "aaaaaaaaaaaaaaaaaaaaaaa";
+    p = boost::lexical_cast<boost::filesystem::path>(s1);
+    BOOST_CHECK(!p.empty());
+    BOOST_CHECK_EQUAL(p, s1);
+    p.clear();
+
+    const char ab[] = "aaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+    p = boost::lexical_cast<boost::filesystem::path>(ab);
+    BOOST_CHECK(!p.empty());
+    BOOST_CHECK_EQUAL(p, ab);
+}
+
@@ -0,0 +1,527 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011.
+//
+//  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/cstdint.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+void test_conversion_from_to_float();
+void test_conversion_from_to_double();
+void test_conversion_from_to_long_double();
+
+using namespace boost;
+
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast float types unit test");
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_float));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_double));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long_double));
+
+    return suite;
+}
+
+
+// Replace "-,999" with "-999".
+template<class CharT>
+std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
+{
+    std::locale loc;
+    std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
+    std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
+
+    if(np.grouping().empty())
+        return str;
+
+    CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
+
+    if(str.find(prefix) != 0)
+        return str;
+
+    prefix[1] = CharT();
+    str.replace(0, 2, prefix);
+    return str;
+}
+
+template<class CharT, class T>
+std::basic_string<CharT> to_str(T t)
+{
+    std::basic_ostringstream<CharT> o;
+    o << t;
+    return to_str_gcc_workaround(o.str());
+}
+
+
+template<class T>
+void test_conversion_from_to_float_for_locale()
+{
+    std::locale current_locale;
+    typedef std::numpunct<char> numpunct;
+    numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
+    if ( !np.grouping().empty() )
+    {
+        BOOST_CHECK_THROW(
+                lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
+                , bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
+
+        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
+        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
+        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
+        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
+        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
+#endif
+        // Exception must not be thrown, when we are using no separators at all
+        BOOST_CHECK_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (std::numeric_limits<T>::epsilon()) );
+    }
+}
+
+
+
+
+/*
+ * Converts char* [and wchar_t*] to float number type and checks, that generated
+ * number does not exceeds allowed epsilon.
+ */
+#ifndef BOOST_LCAST_NO_WCHAR_T
+#define CHECK_CLOSE_ABS_DIFF(VAL,PREFIX)                                                          \
+    converted_val = lexical_cast<test_t>(#VAL);                                                   \
+    BOOST_CHECK_CLOSE_FRACTION( (VAL ## L? VAL ## L : std::numeric_limits<test_t>::epsilon()),    \
+                       (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),  \
+                       std::numeric_limits<test_t>::epsilon()                                     \
+                     );                                                                           \
+    BOOST_CHECK_EQUAL(converted_val, lexical_cast<test_t>(L## #VAL) );
+
+#else
+#define CHECK_CLOSE_ABS_DIFF(VAL,TYPE)                                                            \
+    converted_val = lexical_cast<test_t>(#VAL);                                                   \
+    BOOST_CHECK_CLOSE_FRACTION( (VAL ## L? VAL ## L : std::numeric_limits<test_t>::epsilon()),    \
+                       (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),  \
+                       std::numeric_limits<test_t>::epsilon()                                     \
+                     );
+#endif
+
+template <class TestType>
+void test_converion_to_float_types()
+{
+    typedef TestType test_t;
+    test_t converted_val;
+
+    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>('0'));
+
+    unsigned char const uc_one = '1';
+    unsigned char const uc_zero ='0';
+    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(uc_zero));
+
+    signed char const sc_one = '1';
+    signed char const sc_zero ='0';
+    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(sc_zero));
+
+    BOOST_CHECK_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (std::numeric_limits<test_t>::epsilon()) );
+
+//    VC failes the next test
+//    BOOST_CHECK_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (std::numeric_limits<test_t>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(
+                                    0.1111111111111111111111111111111111111111111111111111111111111111111111111L
+            , lexical_cast<test_t>("0.1111111111111111111111111111111111111111111111111111111111111111111111111")
+            , (std::numeric_limits<test_t>::epsilon()) );
+
+    CHECK_CLOSE_ABS_DIFF(1,test_t);
+    BOOST_CHECK_EQUAL(0,lexical_cast<test_t>("0"));
+    CHECK_CLOSE_ABS_DIFF(-1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1.0, test_t);
+    CHECK_CLOSE_ABS_DIFF(0.0, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1.0,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1e1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1.0e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0.0e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1.0e1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1e-1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1.0e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0.0e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1.0e-1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1E1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1.0E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0.0E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1.0E1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1E-1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(1.0E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(0.0E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-1.0E-1, test_t);
+
+    CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-.0E-1, test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10.0, test_t);
+    CHECK_CLOSE_ABS_DIFF(00.0, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10.0,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10e1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10.0e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00.0e1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10.0e1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10e-1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10.0e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00.0e-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10.0e-1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10E1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10.0E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00.0E1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10.0E1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10E-1,test_t);
+
+    CHECK_CLOSE_ABS_DIFF(10.0E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(00.0E-1, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10.0E-1, test_t);
+
+    CHECK_CLOSE_ABS_DIFF(-10101.0E-011, test_t);
+    CHECK_CLOSE_ABS_DIFF(-10101093, test_t);
+    CHECK_CLOSE_ABS_DIFF(10101093, test_t);
+
+    CHECK_CLOSE_ABS_DIFF(-.34, test_t);
+    CHECK_CLOSE_ABS_DIFF(.34, test_t);
+    CHECK_CLOSE_ABS_DIFF(.34e10, test_t);
+
+    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.e"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.E"), bad_lexical_cast);
+
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("10E"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("10e"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("10E-"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("10e-"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("e1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("e-1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("e-"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>(".e"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("."), bad_lexical_cast);
+
+    BOOST_CHECK_THROW(lexical_cast<test_t>("-B"), bad_lexical_cast);
+
+    // Following two tests are not valid for C++11 compilers    
+    //BOOST_CHECK_THROW(lexical_cast<test_t>("0xB"), bad_lexical_cast);
+    //BOOST_CHECK_THROW(lexical_cast<test_t>("0x0"), bad_lexical_cast);
+
+    BOOST_CHECK_THROW(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("-"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>('\0'), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>('-'), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>('.'), bad_lexical_cast);
+}
+
+template <class T>
+void test_float_typess_for_overflows()
+{
+    typedef T test_t;
+    test_t minvalue = (std::numeric_limits<test_t>::min)();
+    std::string s_min_value = lexical_cast<std::string>(minvalue);
+    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (std::numeric_limits<test_t>::epsilon() * 2));
+
+    test_t maxvalue = (std::numeric_limits<test_t>::max)();
+    std::string s_max_value = lexical_cast<std::string>(maxvalue);
+    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(s_max_value), (std::numeric_limits<test_t>::epsilon()));
+
+#ifndef _LIBCPP_VERSION
+    // libc++ had a bug in implementation of stream conversions for values that must be represented as infinity. 
+    // http://llvm.org/bugs/show_bug.cgi?id=15723#c4
+    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);
+
+    // VC9 can fail the following tests on floats and doubles when using stingstream...
+    BOOST_CHECK_THROW(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
+#endif
+
+    if ( is_same<test_t,float>::value )
+    {
+        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
+        BOOST_CHECK(
+                (std::numeric_limits<double>::min)() - std::numeric_limits<test_t>::epsilon()
+                <= lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
+                && lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
+                <= (std::numeric_limits<double>::min)() + std::numeric_limits<test_t>::epsilon()
+        );
+    }
+
+    if ( sizeof(test_t) < sizeof(long double) )
+    {
+        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
+        BOOST_CHECK(
+                (std::numeric_limits<long double>::min)() - std::numeric_limits<test_t>::epsilon()
+                <= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
+                && lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
+                <= (std::numeric_limits<long double>::min)() + std::numeric_limits<test_t>::epsilon()
+        );
+    }
+}
+
+#undef CHECK_CLOSE_ABS_DIFF
+
+// Epsilon is multiplied by 2 because of two lexical conversions
+#define TEST_TO_FROM_CAST_AROUND_TYPED(VAL,STRING_TYPE)                             \
+    test_value = VAL + std::numeric_limits<test_t>::epsilon() * i ;                 \
+    converted_val = lexical_cast<test_t>( lexical_cast<STRING_TYPE>(test_value) );  \
+    BOOST_CHECK_CLOSE_FRACTION(                                                     \
+            test_value,                                                             \
+            converted_val,                                                          \
+            std::numeric_limits<test_t>::epsilon() * 2                              \
+        );
+
+/*
+ * For interval [ from_mult*epsilon+VAL, to_mult*epsilon+VAL ], converts float type
+ * numbers to string[wstring] and then back to float type, then compares initial
+ * values and generated.
+ * Step is epsilon
+ */
+#ifndef BOOST_LCAST_NO_WCHAR_T
+#   define TEST_TO_FROM_CAST_AROUND(VAL)                    \
+    for(i=from_mult; i<=to_mult; ++i) {                     \
+        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string)    \
+        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::wstring)   \
+    }
+#else
+#   define TEST_TO_FROM_CAST_AROUND(VAL)                    \
+    for(i=from_mult; i<=to_mult; ++i) {                     \
+        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string)    \
+    }
+#endif
+
+template <class TestType>
+void test_converion_from_to_float_types()
+{
+    typedef TestType test_t;
+    test_t test_value;
+    test_t converted_val;
+
+    int i;
+    int from_mult = -50;
+    int to_mult = 50;
+
+    TEST_TO_FROM_CAST_AROUND( 0.0 );
+
+    long double val1;
+    for(val1 = 1.0e-10L; val1 < 1e11; val1*=10 )
+        TEST_TO_FROM_CAST_AROUND( val1 );
+
+    long double val2;
+    for(val2 = -1.0e-10L; val2 > -1e11; val2*=10 )
+        TEST_TO_FROM_CAST_AROUND( val2 );
+
+    from_mult = -100;
+    to_mult = 0;
+    TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::max)() );
+
+    from_mult = 0;
+    to_mult = 100;
+    TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::min)() );
+}
+
+#undef TEST_TO_FROM_CAST_AROUND
+#undef TEST_TO_FROM_CAST_AROUND_TYPED
+
+
+template<class T, class CharT>
+void test_conversion_from_float_to_char(CharT zero)
+{
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
+
+    BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
+
+    T t = (std::numeric_limits<T>::max)();
+    BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
+}
+
+template<class T, class CharT>
+void test_conversion_from_char_to_float(CharT zero)
+{
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (std::numeric_limits<T>::epsilon()) );
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (std::numeric_limits<T>::epsilon()) );
+
+    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
+}
+
+struct restore_oldloc
+{
+    std::locale oldloc;
+    ~restore_oldloc() { std::locale::global(oldloc); }
+};
+
+template<class T>
+void test_conversion_from_to_float()
+{    char const zero = '0';
+    signed char const szero = '0';
+    unsigned char const uzero = '0';
+    test_conversion_from_float_to_char<T>(zero);
+    test_conversion_from_char_to_float<T>(zero);
+    test_conversion_from_float_to_char<T>(szero);
+    test_conversion_from_char_to_float<T>(szero);
+    test_conversion_from_float_to_char<T>(uzero);
+    test_conversion_from_char_to_float<T>(uzero);
+    #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    wchar_t const wzero = L'0';
+    test_conversion_from_float_to_char<T>(wzero);
+    test_conversion_from_char_to_float<T>(wzero);
+    #endif
+
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, std::numeric_limits<T>::epsilon());
+    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, std::numeric_limits<T>::epsilon());
+
+    BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
+
+    test_converion_to_float_types<T>();
+    test_float_typess_for_overflows<T>();
+    test_converion_from_to_float_types<T>();
+
+
+    typedef std::numpunct<char> numpunct;
+
+    restore_oldloc guard;
+    std::locale const& oldloc = guard.oldloc;
+
+    std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
+    std::string grouping2(grouping1);
+
+    test_conversion_from_to_float_for_locale<T>();
+
+    try
+    {
+        std::locale newloc("");
+        std::locale::global(newloc);
+
+        grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
+    }
+    catch(std::exception const& ex)
+    {
+        std::string msg("Failed to set system locale: ");
+        msg += ex.what();
+        BOOST_TEST_MESSAGE(msg);
+    }
+
+    if(grouping1 != grouping2)
+        test_conversion_from_to_float_for_locale<T>();
+
+    if(grouping1.empty() && grouping2.empty())
+        BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
+}
+
+
+void test_conversion_from_to_float()
+{
+    test_conversion_from_to_float<float>();
+}
+void test_conversion_from_to_double()
+{
+    test_conversion_from_to_float<double>();
+}
+void test_conversion_from_to_long_double()
+{
+// We do not run tests on compilers with bugs
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    test_conversion_from_to_float<long double>();
+#endif
+    BOOST_CHECK(true);
+}
+
+
+
+
+
+
+
@@ -0,0 +1,205 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011.
+//
+//  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/math/special_functions/sign.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+using namespace boost;
+
+template <class T>
+bool is_pos_inf(T value)
+{
+    return (boost::math::isinf)(value) && !(boost::math::signbit)(value);
+}
+
+template <class T>
+bool is_neg_inf(T value)
+{
+    return (boost::math::isinf)(value) && (boost::math::signbit)(value);
+}
+
+template <class T>
+bool is_pos_nan(T value)
+{
+    return (boost::math::isnan)(value) && !(boost::math::signbit)(value);
+}
+
+template <class T>
+bool is_neg_nan(T value)
+{
+    /* There is some strange behaviour on Itanium platform with -nan nuber for long double.
+    * It is a IA64 feature, or it is a boost::math feature, not a lexical_cast bug */
+#if defined(__ia64__) || defined(_M_IA64)
+    return (boost::math::isnan)(value)
+            && ( boost::is_same<T, long double >::value || (boost::math::signbit)(value) );
+#else
+    return (boost::math::isnan)(value) && (boost::math::signbit)(value);
+#endif
+}
+
+template <class T>
+void test_inf_nan_templated()
+{
+    typedef T test_t;
+
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("inf") ) );
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INF") ) );
+
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inf") ) );
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INF") ) );
+
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+inf") ) );
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INF") ) );
+
+    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_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") ) );
+
+    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") ) );
+
+    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 );
+
+    BOOST_CHECK(lexical_cast<std::string>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
+                == "-inf" );
+    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
+    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
+#if !defined(__ia64__) && !defined(_M_IA64)
+    BOOST_CHECK(lexical_cast<std::string>(
+                (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
+                == "-nan" );
+#endif
+
+#ifndef  BOOST_LCAST_NO_WCHAR_T
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
+
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
+
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
+
+    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_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") ) );
+
+    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
+    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
+
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
+
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
+    BOOST_CHECK_THROW( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
+
+    BOOST_CHECK(lexical_cast<std::wstring>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
+                == L"-inf" );
+    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
+    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
+#if !defined(__ia64__) && !defined(_M_IA64)
+    BOOST_CHECK(lexical_cast<std::wstring>(
+                (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
+                == L"-nan" );
+#endif
+
+#endif
+}
+
+void test_inf_nan_float()
+{
+    test_inf_nan_templated<float >();
+}
+
+void test_inf_nan_double()
+{
+    test_inf_nan_templated<double >();
+}
+
+void test_inf_nan_long_double()
+{
+// We do not run tests on compilers with bugs
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    test_inf_nan_templated<long double >();
+#endif
+    BOOST_CHECK(true);
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
+    suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
+    suite->add(BOOST_TEST_CASE(&test_inf_nan_double));
+    suite->add(BOOST_TEST_CASE(&test_inf_nan_long_double));
+
+    return suite;
+}
@@ -0,0 +1,653 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Terje Sletteb and Kevlin Henney, 2005.
+//  Copyright Alexander Nasonov, 2006.
+//  Copyright Antony Polukhin, 2011-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).
+//
+// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
+
+//
+// We need this #define before any #includes: otherwise msvc will emit warnings
+// deep within std::string, resulting from our (perfectly legal) use of basic_string
+// with a custom traits class:
+//
+#define _SCL_SECURE_NO_WARNINGS
+
+#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/cstdint.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include <boost/type_traits/integral_promotion.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <string>
+#include <vector>
+#include <memory>
+
+#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
+    && !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
+#define LCAST_TEST_LONGLONG
+#endif
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+// Test all 65536 values if true:
+bool const lcast_test_small_integral_types_completely = false;
+
+// lcast_integral_test_counter: use when testing all values of an integral
+// types is not possible. Max. portable value is 32767.
+int const lcast_integral_test_counter=500;
+
+using namespace boost;
+
+
+
+void test_conversion_from_to_short();
+void test_conversion_from_to_ushort();
+void test_conversion_from_to_int();
+void test_conversion_from_to_uint();
+void test_conversion_from_to_long();
+void test_conversion_from_to_ulong();
+void test_conversion_from_to_intmax_t();
+void test_conversion_from_to_uintmax_t();
+#ifdef LCAST_TEST_LONGLONG
+void test_conversion_from_to_longlong();
+void test_conversion_from_to_ulonglong();
+#endif
+#ifdef BOOST_HAS_INT128
+void test_conversion_from_to_int128();
+void test_conversion_from_to_uint128();
+#endif
+void test_integral_conversions_on_min_max();
+
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test on integral types");
+
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_short));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ushort));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulong));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_intmax_t));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uintmax_t));
+#ifdef LCAST_TEST_LONGLONG
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_longlong));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulonglong));
+#endif
+#ifdef BOOST_HAS_INT128
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int128));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint128));
+#endif
+    suite->add(BOOST_TEST_CASE(&test_integral_conversions_on_min_max));
+
+    return suite;
+}
+
+template<class T, class CharT>
+void test_conversion_from_integral_to_char(CharT zero)
+{
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
+    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
+
+    BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
+
+    T t = (std::numeric_limits<T>::max)();
+    BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
+}
+
+template<class T, class CharT>
+void test_conversion_from_char_to_integral(CharT zero)
+{
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 0)) == static_cast<T>(0) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 1)) == static_cast<T>(1) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 2)) == static_cast<T>(2) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 3)) == static_cast<T>(3) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 4)) == static_cast<T>(4) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 5)) == static_cast<T>(5) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 6)) == static_cast<T>(6) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 7)) == static_cast<T>(7) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 8)) == static_cast<T>(8) );
+    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 9)) == static_cast<T>(9) );
+
+    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
+}
+
+template<class T>
+void test_conversion_from_integral_to_integral()
+{
+    T t = 0;
+    BOOST_CHECK(lexical_cast<T>(t) == t);
+
+    // Next two variables are used to supress warnings.
+    int st = 32767; unsigned int ut = st;
+    t = st;
+    BOOST_CHECK(lexical_cast<short>(t) == st);
+    BOOST_CHECK(lexical_cast<unsigned short>(t) == ut);
+    BOOST_CHECK(lexical_cast<int>(t) == st);
+    BOOST_CHECK(lexical_cast<unsigned int>(t) == ut);
+    BOOST_CHECK(lexical_cast<long>(t) == st);
+    BOOST_CHECK(lexical_cast<unsigned long>(t) == ut);
+
+    t = (std::numeric_limits<T>::max)();
+    BOOST_CHECK(lexical_cast<T>(t) == t);
+
+    t = (std::numeric_limits<T>::min)();
+    BOOST_CHECK(lexical_cast<T>(t) == t);
+}
+
+
+
+
+// Replace "-,999" with "-999".
+template<class CharT>
+std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
+{
+    std::locale loc;
+    std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
+    std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
+
+    if(np.grouping().empty())
+        return str;
+
+    CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
+
+    if(str.find(prefix) != 0)
+        return str;
+
+    prefix[1] = CharT();
+    str.replace(0, 2, prefix);
+    return str;
+}
+
+template<class CharT, class T>
+std::basic_string<CharT> to_str(T t)
+{
+    std::basic_ostringstream<CharT> o;
+    o << t;
+    return to_str_gcc_workaround(o.str());
+}
+
+
+template<class T, class CharT>
+void test_conversion_from_integral_to_string(CharT)
+{
+    typedef std::numeric_limits<T> limits;
+    typedef std::basic_string<CharT> string_type;
+
+    T t;
+
+    t = (limits::min)();
+    BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+
+    t = (limits::max)();
+    BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+
+    if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
+        // min and max have already been tested.
+        for(t = 1 + (limits::min)(); t != (limits::max)(); ++t)
+            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+    else
+    {
+        T const min_val = (limits::min)();
+        T const max_val = (limits::max)();
+        T const half_max_val = max_val / 2;
+        T const cnt = lcast_integral_test_counter; // to supress warnings
+        unsigned int const counter = cnt < half_max_val ? cnt : half_max_val;
+
+        unsigned int i;
+
+        // Test values around min:
+        t = min_val;
+        for(i = 0; i < counter; ++i, ++t)
+            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+
+        // Test values around max:
+        t = max_val;
+        for(i = 0; i < counter; ++i, --t)
+            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+
+        // Test values around zero:
+        if(limits::is_signed)
+            for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
+                BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+
+        // Test values around 100, 1000, 10000, ...
+        T ten_power = 100;
+        for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
+        {
+            // ten_power + 100 probably never overflows
+            for(t = ten_power - 100; t != ten_power + 100; ++t)
+                BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+        }
+    }
+}
+
+template<class T, class CharT>
+void test_conversion_from_string_to_integral(CharT)
+{
+    typedef std::numeric_limits<T> limits;
+    typedef std::basic_string<CharT> string_type;
+
+    string_type s;
+    string_type const zero = to_str<CharT>(0);
+    string_type const nine = to_str<CharT>(9);
+    T const min_val = (limits::min)();
+    T const max_val = (limits::max)();
+
+    s = to_str<CharT>(min_val);
+    BOOST_CHECK_EQUAL(lexical_cast<T>(s), min_val);
+    if(limits::is_signed)
+    {
+        BOOST_CHECK_THROW(lexical_cast<T>(s + zero), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>(s + nine), bad_lexical_cast);
+    }
+
+    s = to_str<CharT>(max_val);
+    BOOST_CHECK_EQUAL(lexical_cast<T>(s), max_val);
+    {
+        BOOST_CHECK_THROW(lexical_cast<T>(s + zero), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>(s + nine), bad_lexical_cast);
+
+        s = to_str<CharT>(max_val);
+        for (int i =1; i <=10; ++i) {
+            s[s.size()-1] += 1;
+            BOOST_CHECK_THROW(lexical_cast<T>( s ), bad_lexical_cast);
+        }
+
+        s = to_str<CharT>(max_val);
+        std::locale loc;
+        typedef std::numpunct<char> numpunct;
+        if ( BOOST_USE_FACET(numpunct, loc).grouping().empty() ) {
+            // Following tests work well for locale C
+            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+s), max_val);
+            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
+            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
+        }
+
+        for (int i =1; i <=256; ++i) {
+            BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
+        }
+
+        typedef BOOST_DEDUCED_TYPENAME boost::integral_promotion<T>::type promoted;
+        if ( !(boost::is_same<T, promoted>::value) )
+        {
+            promoted prom = max_val;
+            s = to_str<CharT>(max_val);
+            for (int i =1; i <=256; ++i) {
+                BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(prom+i) ), bad_lexical_cast);
+                BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
+            }
+        }
+    }
+
+    if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
+        // min and max have already been tested.
+        for(T t = 1 + min_val; t != max_val; ++t)
+            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+    else
+    {
+        T const half_max_val = max_val / 2;
+        T const cnt = lcast_integral_test_counter; // to supress warnings
+        unsigned int const counter = cnt < half_max_val ? cnt : half_max_val;
+
+        T t;
+        unsigned int i;
+
+        // Test values around min:
+        t = min_val;
+        for(i = 0; i < counter; ++i, ++t)
+            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+
+        // Test values around max:
+        t = max_val;
+        for(i = 0; i < counter; ++i, --t)
+            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+
+        // Test values around zero:
+        if(limits::is_signed)
+            for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
+                BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+
+        // Test values around 100, 1000, 10000, ...
+        T ten_power = 100;
+        for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
+        {
+            // ten_power + 100 probably never overflows
+            for(t = ten_power - 100; t != ten_power + 100; ++t)
+                BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+        }
+    }
+}
+
+template<class T>
+void test_conversion_from_to_integral_for_locale()
+{
+    std::locale current_locale;
+    typedef std::numpunct<char> numpunct;
+    numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
+    if ( !np.grouping().empty() )
+    {
+        BOOST_CHECK_THROW(
+                lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
+                , bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
+
+        // Exception must not be thrown, when we are using no separators at all
+        BOOST_CHECK( lexical_cast<T>("30000") == static_cast<T>(30000) );
+    }
+
+
+    test_conversion_from_integral_to_integral<T>();
+
+    // This is a part of test_conversion_from_integral_to_string<T>('0') method,
+    // but with BOOST_CHECK_EQUAL instead of BOOST_CHECK. It is required to see 
+    // what is produced by the to_str<char>(t) method in situations when result 
+    // is different. BOOST_CHECK does not work with wchar_t.
+    typedef std::numeric_limits<T> limits;
+    T t = (limits::min)();
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(t), to_str<char>(t));
+
+    test_conversion_from_integral_to_string<T>('0');
+    test_conversion_from_string_to_integral<T>('0');
+#if !defined(BOOST_LCAST_NO_WCHAR_T)
+    if (lexical_cast<std::wstring>(t) != to_str<wchar_t>(t)) {
+        // Something went wrong, and now we are attempting to find and print the 
+        // difference.
+        std::wstring wstr = to_str<wchar_t>(t);
+        std::string lcast_str = lexical_cast<std::string>(t);
+        std::string str;
+        str.reserve(wstr.size());
+        for (std::size_t i = 0; i < wstr.size(); ++i) {
+            str.push_back(static_cast<char>(wstr[i]));
+        }
+        
+        BOOST_CHECK_EQUAL(lcast_str.length(), lexical_cast<std::wstring>(t).length());
+        BOOST_CHECK_EQUAL(to_str<char>(t), str);
+        BOOST_CHECK_EQUAL(lcast_str, str);
+    }
+
+    test_conversion_from_integral_to_string<T>(L'0');
+    test_conversion_from_string_to_integral<T>(L'0');
+#endif
+}
+
+struct restore_oldloc
+{
+    std::locale oldloc;
+    ~restore_oldloc() { std::locale::global(oldloc); }
+};
+
+template<class T>
+void test_conversion_from_to_integral_minimal()
+{
+    char const zero = '0';
+    signed char const szero = '0';
+    unsigned char const uzero = '0';
+    test_conversion_from_integral_to_char<T>(zero);
+    test_conversion_from_char_to_integral<T>(zero);
+    test_conversion_from_integral_to_char<T>(szero);
+    test_conversion_from_char_to_integral<T>(szero);
+    test_conversion_from_integral_to_char<T>(uzero);
+    test_conversion_from_char_to_integral<T>(uzero);
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    wchar_t const wzero = L'0';
+    test_conversion_from_integral_to_char<T>(wzero);
+    test_conversion_from_char_to_integral<T>(wzero);
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+    char16_t const u16zero = u'0';
+    test_conversion_from_integral_to_char<T>(u16zero);
+    test_conversion_from_char_to_integral<T>(u16zero);
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+    char32_t const u32zero = u'0';
+    test_conversion_from_integral_to_char<T>(u32zero);
+    test_conversion_from_char_to_integral<T>(u32zero);
+#endif
+
+    BOOST_CHECK(lexical_cast<T>("-1") == static_cast<T>(-1));
+    BOOST_CHECK(lexical_cast<T>("-9") == static_cast<T>(-9));
+    BOOST_CHECK(lexical_cast<T>(-1) == static_cast<T>(-1));
+    BOOST_CHECK(lexical_cast<T>(-9) == static_cast<T>(-9));
+
+    BOOST_CHECK_THROW(lexical_cast<T>("-1.0"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>("-9.0"), bad_lexical_cast);
+    BOOST_CHECK(lexical_cast<T>(-1.0) == static_cast<T>(-1));
+    BOOST_CHECK(lexical_cast<T>(-9.0) == static_cast<T>(-9));
+
+    BOOST_CHECK(lexical_cast<T>(static_cast<T>(1)) == static_cast<T>(1));
+    BOOST_CHECK(lexical_cast<T>(static_cast<T>(9)) == static_cast<T>(9));
+    BOOST_CHECK_THROW(lexical_cast<T>(1.1f), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>(1.1), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>(1.1L), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>(1.0001f), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>(1.0001), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>(1.0001L), bad_lexical_cast);
+
+    BOOST_CHECK(lexical_cast<T>("+1") == static_cast<T>(1) );
+    BOOST_CHECK(lexical_cast<T>("+9") == static_cast<T>(9) );
+    BOOST_CHECK(lexical_cast<T>("+10") == static_cast<T>(10) );
+    BOOST_CHECK(lexical_cast<T>("+90") == static_cast<T>(90) );
+    BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
+    // test_conversion_from_to_integral_for_locale
+
+    // Overflow test case from David W. Birdsall
+    std::string must_owerflow_str =             (sizeof(T) < 16 ?  "160000000000000000000" :  "1600000000000000000000000000000000000000");
+    std::string must_owerflow_negative_str =    (sizeof(T) < 16 ? "-160000000000000000000" : "-1600000000000000000000000000000000000000");
+    for (int i = 0; i < 15; ++i) {
+        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_str), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_negative_str), bad_lexical_cast);
+
+        must_owerflow_str += '0';
+        must_owerflow_negative_str += '0';
+    }
+}
+
+template<class T>
+void test_conversion_from_to_integral()
+{
+    test_conversion_from_to_integral_minimal<T>();
+    typedef std::numpunct<char> numpunct;
+
+    restore_oldloc guard;
+    std::locale const& oldloc = guard.oldloc;
+
+    std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
+    std::string grouping2(grouping1);
+
+    test_conversion_from_to_integral_for_locale<T>();
+
+    try
+    {
+        std::locale newloc("");
+        std::locale::global(newloc);
+
+        grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
+    }
+    catch(std::exception const& ex)
+    {
+        std::string msg("Failed to set system locale: ");
+        msg += ex.what();
+        BOOST_TEST_MESSAGE(msg);
+    }
+
+    if(grouping1 != grouping2)
+        test_conversion_from_to_integral_for_locale<T>();
+
+    if(grouping1.empty() && grouping2.empty())
+        BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
+}
+
+void test_conversion_from_to_short()
+{
+    test_conversion_from_to_integral<short>();
+}
+
+void test_conversion_from_to_ushort()
+{
+    test_conversion_from_to_integral<unsigned short>();
+}
+
+void test_conversion_from_to_int()
+{
+    test_conversion_from_to_integral<int>();
+}
+
+void test_conversion_from_to_uint()
+{
+    test_conversion_from_to_integral<unsigned int>();
+}
+
+void test_conversion_from_to_long()
+{
+    test_conversion_from_to_integral<long>();
+}
+
+void test_conversion_from_to_ulong()
+{
+    test_conversion_from_to_integral<unsigned long>();
+}
+
+void test_conversion_from_to_intmax_t()
+{
+    test_conversion_from_to_integral<boost::intmax_t>();
+}
+
+void test_conversion_from_to_uintmax_t()
+{
+    test_conversion_from_to_integral<boost::uintmax_t>();
+}
+
+#if defined(BOOST_HAS_LONG_LONG)
+
+void test_conversion_from_to_longlong()
+{
+    test_conversion_from_to_integral<boost::long_long_type>();
+}
+
+void test_conversion_from_to_ulonglong()
+{
+    test_conversion_from_to_integral<boost::ulong_long_type>();
+}
+
+#elif defined(BOOST_HAS_MS_INT64)
+
+void test_conversion_from_to_longlong()
+{
+    test_conversion_from_to_integral<__int64>();
+}
+
+void test_conversion_from_to_ulonglong()
+{
+    test_conversion_from_to_integral<unsigned __int64>();
+}
+
+#endif
+
+
+#ifdef BOOST_HAS_INT128
+
+template <bool Specialized, class T>
+struct test_if_specialized {
+    static void test() {}
+};
+
+template <class T>
+struct test_if_specialized<true, T> {
+    static void test() {
+        test_conversion_from_to_integral_minimal<T>();
+    }
+};
+
+void test_conversion_from_to_int128()
+{
+    test_if_specialized<
+        std::numeric_limits<boost::int128_type>::is_specialized, 
+        boost::int128_type
+    >::test();
+}
+
+void test_conversion_from_to_uint128()
+{
+    test_if_specialized<
+        std::numeric_limits<boost::int128_type>::is_specialized, 
+        boost::uint128_type
+    >::test();
+}
+#endif
+
+template <typename SignedT>
+void test_integral_conversions_on_min_max_impl()
+{
+    typedef SignedT signed_t;
+    typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<signed_t>::type unsigned_t;
+    
+    typedef std::numeric_limits<signed_t> s_limits;
+    typedef std::numeric_limits<unsigned_t> uns_limits;
+
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((uns_limits::max)()), (uns_limits::max)());
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((uns_limits::min)()), (uns_limits::min)());
+
+    BOOST_CHECK_EQUAL(lexical_cast<signed_t>((s_limits::max)()), (s_limits::max)());
+    BOOST_CHECK_EQUAL(lexical_cast<signed_t>((uns_limits::min)()), static_cast<signed_t>((uns_limits::min)()));
+
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((s_limits::max)()), static_cast<unsigned_t>((s_limits::max)()));
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((s_limits::min)()), static_cast<unsigned_t>((s_limits::min)()));
+}
+
+void test_integral_conversions_on_min_max()
+{
+    test_integral_conversions_on_min_max_impl<int>();
+    test_integral_conversions_on_min_max_impl<short>();
+
+#ifdef _MSC_VER
+    test_integral_conversions_on_min_max_impl<long int>();
+
+#if defined(BOOST_HAS_LONG_LONG)
+    test_integral_conversions_on_min_max_impl<boost::long_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+    test_integral_conversions_on_min_max_impl<__int64>();
+#endif
+
+#ifdef BOOST_HAS_INT128
+    test_integral_conversions_on_min_max_impl<boost::int128_type>();
+#endif
+#endif
+
+}
+
+
@@ -0,0 +1,245 @@
+//  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;
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU16
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU32
+#endif
+
+struct class_with_user_defined_sream_operators {
+    int i;
+
+    operator int() const {
+        return i;
+    }
+};
+
+template <class CharT>
+inline std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, class_with_user_defined_sream_operators& rhs)
+{
+    return istr >> rhs.i;
+}
+
+
+template <class RngT>
+void do_test_iterator_range_impl(const RngT& rng)
+{
+    BOOST_CHECK_EQUAL(lexical_cast<int>(rng), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<int>(rng.begin(), rng.size()), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(rng), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(rng.begin(), rng.size()), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<short>(rng), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<short>(rng.begin(), rng.size()), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng.begin(), rng.size()), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<long int>(rng), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<long int>(rng.begin(), rng.size()), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng.begin(), rng.size()), 1u);
+
+#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
+    BOOST_CHECK_EQUAL(lexical_cast<float>(rng), 1.0f);
+    BOOST_CHECK_EQUAL(lexical_cast<float>(rng.begin(), rng.size()), 1.0f);
+    BOOST_CHECK_EQUAL(lexical_cast<double>(rng), 1.0);
+    BOOST_CHECK_EQUAL(lexical_cast<double>(rng.begin(), rng.size()), 1.0);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng), 1.0L);
+    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng.begin(), rng.size()), 1.0L);
+#endif
+    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng), 1);
+#endif
+#if defined(BOOST_HAS_LONG_LONG)
+    BOOST_CHECK_EQUAL(lexical_cast<boost::ulong_long_type>(rng), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<boost::ulong_long_type>(rng.begin(), rng.size()), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<boost::long_long_type>(rng), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<boost::long_long_type>(rng.begin(), rng.size()), 1);
+#elif defined(BOOST_HAS_MS_INT64)
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng.begin(), rng.size()), 1u);
+    BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng), 1);
+    BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng.begin(), rng.size()), 1);
+#endif
+}
+
+template <class CharT>
+void test_it_range_using_any_chars(CharT* one, CharT* eleven)
+{
+    typedef CharT test_char_type;
+
+    // Zero terminated
+    iterator_range<test_char_type*> rng1(one, one + 1);
+    do_test_iterator_range_impl(rng1);
+
+    iterator_range<const test_char_type*> crng1(one, one + 1);
+    do_test_iterator_range_impl(crng1);
+
+    // Non zero terminated
+    iterator_range<test_char_type*> rng2(eleven, eleven + 1);
+    do_test_iterator_range_impl(rng2);
+
+    iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
+    do_test_iterator_range_impl(crng2);
+}
+
+template <class CharT>
+void test_it_range_using_char(CharT* one, CharT* eleven)
+{
+    typedef CharT test_char_type;
+
+    iterator_range<test_char_type*> rng1(one, one + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng1), "1");
+
+    iterator_range<const test_char_type*> crng1(one, one + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng1), "1");
+
+    iterator_range<test_char_type*> rng2(eleven, eleven + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng2), "1");
+
+    iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng2), "1");
+
+    BOOST_CHECK_EQUAL(lexical_cast<float>(rng1), 1.0f);
+    BOOST_CHECK_EQUAL(lexical_cast<double>(rng1), 1.0);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng1), 1.0L);
+#endif
+    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng1), 1);
+
+    BOOST_CHECK_EQUAL(lexical_cast<float>(crng2), 1.0f);
+    BOOST_CHECK_EQUAL(lexical_cast<double>(crng2), 1.0);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    BOOST_CHECK_EQUAL(lexical_cast<long double>(crng2), 1.0L);
+#endif
+    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(crng2), 1);
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    BOOST_CHECK(lexical_cast<std::wstring>(rng1) == L"1");
+    BOOST_CHECK(lexical_cast<std::wstring>(crng1) == L"1");
+    BOOST_CHECK(lexical_cast<std::wstring>(rng2) == L"1");
+    BOOST_CHECK(lexical_cast<std::wstring>(crng2) == L"1");
+#endif
+
+#if defined(BOOST_LC_RUNU16) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+    typedef std::basic_string<char16_t> my_char16_string;
+    BOOST_CHECK(lexical_cast<my_char16_string>(rng1) == u"1");
+    BOOST_CHECK(lexical_cast<my_char16_string>(crng1) == u"1");
+    BOOST_CHECK(lexical_cast<my_char16_string>(rng2) == u"1");
+    BOOST_CHECK(lexical_cast<my_char16_string>(crng2) == u"1");
+#endif
+
+#if defined(BOOST_LC_RUNU32) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+    typedef std::basic_string<char32_t> my_char32_string;
+    BOOST_CHECK(lexical_cast<my_char32_string>(rng1) == U"1");
+    BOOST_CHECK(lexical_cast<my_char32_string>(crng1) == U"1");
+    BOOST_CHECK(lexical_cast<my_char32_string>(rng2) == U"1");
+    BOOST_CHECK(lexical_cast<my_char32_string>(crng2) == U"1");
+#endif
+}
+
+void test_char_iterator_ranges()
+{
+    typedef char test_char_type;
+    test_char_type data1[] = "1";
+    test_char_type data2[] = "11";
+    test_it_range_using_any_chars(data1, data2);
+    test_it_range_using_char(data1, data2);
+}
+
+
+
+void test_unsigned_char_iterator_ranges()
+{
+    typedef unsigned char test_char_type;
+    test_char_type data1[] = "1";
+    test_char_type data2[] = "11";
+    test_it_range_using_any_chars(data1, data2);
+    test_it_range_using_char(data1, data2);
+}
+
+void test_signed_char_iterator_ranges()
+{
+    typedef signed char test_char_type;
+    test_char_type data1[] = "1";
+    test_char_type data2[] = "11";
+    test_it_range_using_any_chars(data1, data2);
+    test_it_range_using_char(data1, data2);
+}
+
+void test_wchar_iterator_ranges()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    typedef wchar_t test_char_type;
+    test_char_type data1[] = L"1";
+    test_char_type data2[] = L"11";
+    test_it_range_using_any_chars(data1, data2);
+#endif
+
+    BOOST_CHECK(true);
+}
+
+void test_char16_iterator_ranges()
+{
+#if defined(BOOST_LC_RUNU16)
+    typedef char16_t test_char_type;
+    test_char_type data1[] = u"1";
+    test_char_type data2[] = u"11";
+    test_it_range_using_any_chars(data1, data2);
+#endif
+
+    BOOST_CHECK(true);
+}
+
+void test_char32_iterator_ranges()
+{
+#if defined(BOOST_LC_RUNU32)
+    typedef char32_t test_char_type;
+    test_char_type data1[] = U"1";
+    test_char_type data2[] = U"11";
+    test_it_range_using_any_chars(data1, data2);
+#endif
+
+    BOOST_CHECK(true);
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite = BOOST_TEST_SUITE("lexical_cast. Testing conversions using iterator_range<>");
+    suite->add(BOOST_TEST_CASE(&test_char_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_unsigned_char_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_signed_char_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_wchar_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_char16_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_char32_iterator_ranges));
+
+    return suite;
+}
@@ -0,0 +1,96 @@
+//  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::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));
+
+}
+
+// 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));
+}
+
+void test_round_conversion_float()
+{
+    test_round_conversion<float>();
+}
+
+void test_round_conversion_double()
+{
+    test_round_conversion<double>();
+    test_msvc_magic_values<double>();
+}
+
+void test_round_conversion_long_double()
+{
+// We do not run tests on compilers with bugs
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    test_round_conversion<long double>();
+    test_msvc_magic_values<long double>();
+#endif
+    BOOST_CHECK(true);
+}
+
@@ -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;
+}
+
@@ -0,0 +1,168 @@
+//  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);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+    BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
+#endif
+    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;
+}
+
@@ -0,0 +1,54 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Alexander Nasonov, 2007.
+//
+//  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 that Source can be non-copyable.
+
+#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/noncopyable.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace boost;
+
+void test_noncopyable();
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test");
+    suite->add(BOOST_TEST_CASE(&test_noncopyable));
+
+    return suite;
+}
+
+class Noncopyable : private boost::noncopyable
+{
+public:
+    Noncopyable() {}
+};
+
+inline std::ostream &operator<<(std::ostream &out, const Noncopyable&)
+{
+    return out << "Noncopyable";
+}
+
+void test_noncopyable()
+{
+    Noncopyable x;
+    BOOST_CHECK(boost::lexical_cast<std::string>(x) == "Noncopyable");
+}
+
@@ -0,0 +1,96 @@
+//  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>
+
+using namespace boost;
+
+#if defined(BOOST_NO_STRINGSTREAM)
+            typedef std::strstream ss_t;
+#else
+            typedef std::stringstream ss_t;
+#endif
+
+void test_void_pointers_conversions()
+{
+    void *p_to_null = NULL;
+    const void *cp_to_data = "Some data";
+    char nonconst_data[5];
+    void *p_to_data = nonconst_data;
+    ss_t ss;
+
+    ss << p_to_null;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
+    ss.str(std::string());
+
+    ss << cp_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
+    ss.str(std::string());
+
+    ss << p_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
+    ss.str(std::string());
+}
+
+struct incomplete_type;
+
+void test_incomplete_type_pointers_conversions()
+{
+    incomplete_type *p_to_null = NULL;
+    const incomplete_type *cp_to_data = NULL;
+    char nonconst_data[5];
+    incomplete_type *p_to_data = reinterpret_cast<incomplete_type*>(nonconst_data);
+    ss_t ss;
+
+    ss << p_to_null;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
+    ss.str(std::string());
+
+    ss << cp_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
+    ss.str(std::string());
+
+    ss << p_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
+    ss.str(std::string());
+}
+
+struct ble;
+typedef struct ble *meh;
+std::ostream& operator <<(std::ostream &o, meh) {
+  o << "yay";
+  return o;
+}
+
+void test_inomplete_type_with_overloaded_ostream_op() {
+    meh heh = NULL;
+    ss_t ss;
+    ss << heh;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(heh), ss.str());
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast pinters test");
+    suite->add(BOOST_TEST_CASE(&test_void_pointers_conversions));
+    suite->add(BOOST_TEST_CASE(&test_incomplete_type_pointers_conversions));
+    suite->add(BOOST_TEST_CASE(&test_inomplete_type_with_overloaded_ostream_op));
+    return suite;
+}
@@ -0,0 +1,307 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011-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>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/lexical_cast.hpp>
+
+#include <iostream>
+
+
+///////////////////////// char streamable classes ///////////////////////////////////////////
+
+struct streamable_easy { enum ENU {value = 0}; };
+std::ostream& operator << (std::ostream& ostr, const streamable_easy&) {
+    return ostr << streamable_easy::value;
+}
+std::istream& operator >> (std::istream& istr, const streamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_easy::value);
+    return istr;
+}
+
+struct streamable_medium { enum ENU {value = 1}; };
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT>&>::type 
+operator << (std::basic_ostream<CharT>& ostr, const streamable_medium&) {
+    return ostr << streamable_medium::value;
+}
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT>&>::type 
+operator >> (std::basic_istream<CharT>& istr, const streamable_medium&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_medium::value);
+    return istr;
+}
+
+struct streamable_hard { enum ENU {value = 2}; };
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT, TraitsT>&>::type 
+operator << (std::basic_ostream<CharT, TraitsT>& ostr, const streamable_hard&) {
+    return ostr << streamable_hard::value;
+}
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT, TraitsT>&>::type 
+operator >> (std::basic_istream<CharT, TraitsT>& istr, const streamable_hard&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard::value);
+    return istr;
+}
+
+struct streamable_hard2 { enum ENU {value = 3}; };
+template <class TraitsT>
+std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const streamable_hard2&) {
+    return ostr << streamable_hard2::value;
+}
+template <class TraitsT>
+std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const streamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard2::value);
+    return istr;
+}
+
+
+///////////////////////// wchar_t streamable classes ///////////////////////////////////////////
+
+struct wstreamable_easy { enum ENU {value = 4}; };
+std::wostream& operator << (std::wostream& ostr, const wstreamable_easy&) {
+    return ostr << wstreamable_easy::value;
+}
+std::wistream& operator >> (std::wistream& istr, const wstreamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_easy::value);
+    return istr;
+}
+
+struct wstreamable_medium { enum ENU {value = 5}; };
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT>& >::type 
+operator << (std::basic_ostream<CharT>& ostr, const wstreamable_medium&) {
+    return ostr << wstreamable_medium::value;
+}
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT>& >::type 
+operator >> (std::basic_istream<CharT>& istr, const wstreamable_medium&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_medium::value);
+    return istr;
+}
+
+struct wstreamable_hard { enum ENU {value = 6}; };
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT, TraitsT>&>::type 
+operator << (std::basic_ostream<CharT, TraitsT>& ostr, const wstreamable_hard&) {
+    return ostr << wstreamable_hard::value;
+}
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT, TraitsT>&>::type 
+operator >> (std::basic_istream<CharT, TraitsT>& istr, const wstreamable_hard&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard::value);
+    return istr;
+}
+
+struct wstreamable_hard2 { enum ENU {value = 7}; };
+template <class TraitsT>
+std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const wstreamable_hard2&) {
+    return ostr << wstreamable_hard2::value;
+}
+template <class TraitsT>
+std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const wstreamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard2::value);
+    return istr;
+}
+
+///////////////////////// char and wchar_t streamable classes ///////////////////////////////////////////
+
+
+struct bistreamable_easy { enum ENU {value = 8}; };
+std::ostream& operator << (std::ostream& ostr, const bistreamable_easy&) {
+    return ostr << bistreamable_easy::value;
+}
+std::istream& operator >> (std::istream& istr, const bistreamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value);
+    return istr;
+}
+
+std::wostream& operator << (std::wostream& ostr, const bistreamable_easy&) {
+    return ostr << bistreamable_easy::value + 100;
+}
+std::wistream& operator >> (std::wistream& istr, const bistreamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value + 100);
+    return istr;
+}
+
+struct bistreamable_medium { enum ENU {value = 9}; };
+template <class CharT>
+std::basic_ostream<CharT>& operator << (std::basic_ostream<CharT>& ostr, const bistreamable_medium&) {
+    return ostr << bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100);
+}
+template <class CharT>
+std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, const bistreamable_medium&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100));
+    return istr;
+}
+
+struct bistreamable_hard { enum ENU {value = 10}; };
+template <class CharT, class TraitsT>
+std::basic_ostream<CharT, TraitsT>& operator << (std::basic_ostream<CharT, TraitsT>& ostr, const bistreamable_hard&) {
+    return ostr << bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100);
+}
+template <class CharT, class TraitsT>
+std::basic_istream<CharT, TraitsT>& operator >> (std::basic_istream<CharT, TraitsT>& istr, const bistreamable_hard&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100));
+    return istr;
+}
+
+struct bistreamable_hard2 { enum ENU {value = 11}; };
+template <class TraitsT>
+std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const bistreamable_hard2&) {
+    return ostr << bistreamable_hard2::value;
+}
+template <class TraitsT>
+std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const bistreamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value);
+    return istr;
+}
+
+template <class TraitsT>
+std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const bistreamable_hard2&) {
+    return ostr << bistreamable_hard2::value + 100;
+}
+template <class TraitsT>
+std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const bistreamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value + 100);
+    return istr;
+}
+
+
+void test_ostream_character_detection();
+void test_istream_character_detection();
+void test_mixed_stream_character_detection();
+
+boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    boost::unit_test::test_suite *suite = 
+        BOOST_TEST_SUITE("lexical_cast stream character detection");
+    suite->add(BOOST_TEST_CASE(&test_ostream_character_detection));
+    suite->add(BOOST_TEST_CASE(&test_istream_character_detection));
+    suite->add(BOOST_TEST_CASE(&test_mixed_stream_character_detection));
+    
+    return suite;
+}
+
+template <class T>
+static void test_ostr_impl() {
+    T streamable;
+    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value),  boost::lexical_cast<std::string>(streamable));
+}
+
+template <class T>
+static void test_wostr_impl() {
+    T streamable;
+    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
+    // BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable)); // Shall not compile???
+    BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value) == boost::lexical_cast<std::wstring>(streamable));
+}
+
+template <class T>
+static void test_bistr_impl() {
+    T streamable;
+
+    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value),  boost::lexical_cast<std::string>(streamable));
+
+    BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value + 100) == boost::lexical_cast<std::wstring>(streamable));
+}
+
+void test_ostream_character_detection() {
+    test_ostr_impl<streamable_easy>();
+    test_ostr_impl<streamable_medium>();
+    test_ostr_impl<streamable_hard>();
+    test_ostr_impl<streamable_hard2>();
+    
+    test_wostr_impl<wstreamable_easy>();
+    test_wostr_impl<wstreamable_medium>();
+    test_wostr_impl<wstreamable_hard>();
+    test_wostr_impl<wstreamable_hard2>();
+    
+    test_bistr_impl<bistreamable_easy>();
+    test_bistr_impl<bistreamable_medium>();
+    test_bistr_impl<bistreamable_hard>();
+    test_bistr_impl<bistreamable_hard2>();
+}
+
+
+template <class T>
+static void test_istr_impl() {
+    boost::lexical_cast<T>(T::value);
+    boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
+}
+
+template <class T>
+static void test_wistr_impl() {
+    boost::lexical_cast<T>(T::value);
+    //boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value)); // Shall not compile???
+    boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value));
+}
+
+template <class T>
+static void test_bistr_instr_impl() {
+    boost::lexical_cast<T>(T::value);
+    boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
+    boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value + 100));
+}
+
+void test_istream_character_detection() {
+    test_istr_impl<streamable_easy>();
+    test_istr_impl<streamable_medium>();
+    test_istr_impl<streamable_hard>();
+    test_istr_impl<streamable_hard2>();
+    
+    test_wistr_impl<wstreamable_easy>();
+    test_wistr_impl<wstreamable_medium>();
+    test_wistr_impl<wstreamable_hard>();
+    test_wistr_impl<wstreamable_hard2>();
+    
+    test_bistr_instr_impl<bistreamable_easy>();
+    test_bistr_instr_impl<bistreamable_medium>();
+    test_bistr_instr_impl<bistreamable_hard>();
+    test_bistr_instr_impl<bistreamable_hard2>();
+}
+
+
+
+
+
+
+struct wistreamble_ostreamable { enum ENU {value = 200}; };
+std::ostream& operator << (std::ostream& ostr, const wistreamble_ostreamable&) {
+    return ostr << wistreamble_ostreamable::value;
+}
+std::wistream& operator >> (std::wistream& istr, const wistreamble_ostreamable&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wistreamble_ostreamable::value);
+    return istr;
+}
+
+struct istreamble_wostreamable { enum ENU {value = 201}; };
+std::wostream& operator << (std::wostream& ostr, const istreamble_wostreamable&) {
+    return ostr << istreamble_wostreamable::value;
+}
+std::istream& operator >> (std::istream& istr, const istreamble_wostreamable&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, istreamble_wostreamable::value);
+    return istr;
+}
+
+void test_mixed_stream_character_detection() {
+    //boost::lexical_cast<std::wstring>(std::string("qwe")); // TODO: ALLOW IT AS EXTENSION!
+    
+    boost::lexical_cast<wistreamble_ostreamable>(wistreamble_ostreamable::value);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(wistreamble_ostreamable()), wistreamble_ostreamable::value);
+    
+    boost::lexical_cast<istreamble_wostreamable>(istreamble_wostreamable::value);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(istreamble_wostreamable()), istreamble_wostreamable::value);
+}
@@ -0,0 +1,158 @@
+//  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>
+
+#include <boost/lexical_cast.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+template <class T>
+static void test_optimized_types_to_string_const()
+{
+    namespace de = boost::detail;
+    typedef de::lexical_cast_stream_traits<T, std::string> trait_1;
+    BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::char_type, char>::value));
+    BOOST_CHECK(!trait_1::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
+        
+    typedef de::lexical_cast_stream_traits<const T, std::string> trait_2;
+    BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::char_type, char>::value));
+    BOOST_CHECK(!trait_2::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
+
+    typedef de::lexical_cast_stream_traits<T, std::wstring> trait_3;
+    BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::target_char_t, wchar_t>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::char_type, wchar_t>::value));
+
+    BOOST_CHECK((boost::detail::is_character<BOOST_DEDUCED_TYPENAME trait_3::no_cv_src>::value != trait_3::is_string_widening_required_t::value));
+
+    BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
+}    
+
+
+template <class T>
+static void test_optimized_types_to_string()
+{
+    test_optimized_types_to_string_const<T>();
+
+    namespace de = boost::detail;
+    typedef de::lexical_cast_stream_traits<std::string, T> trait_4;
+    BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::char_type, char>::value));
+    BOOST_CHECK(!trait_4::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
+        
+    typedef de::lexical_cast_stream_traits<const std::string, T> trait_5;
+    BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::char_type, char>::value));
+    BOOST_CHECK(!trait_5::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
+
+    typedef de::lexical_cast_stream_traits<const std::wstring, T> trait_6;
+    BOOST_CHECK(!trait_6::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::src_char_t, wchar_t>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::char_type, wchar_t>::value));
+    BOOST_CHECK(!trait_6::is_string_widening_required_t::value);
+}
+
+void test_metafunctions()
+{
+    test_optimized_types_to_string<bool>();
+    test_optimized_types_to_string<char>();
+    test_optimized_types_to_string<unsigned char>();
+    test_optimized_types_to_string<signed char>();
+    test_optimized_types_to_string<short>();
+    test_optimized_types_to_string<unsigned short>();
+    test_optimized_types_to_string<int>();
+    test_optimized_types_to_string<unsigned int>();
+    test_optimized_types_to_string<long>();
+    test_optimized_types_to_string<unsigned long>();
+
+#if defined(BOOST_HAS_LONG_LONG)
+    test_optimized_types_to_string<boost::ulong_long_type>();
+    test_optimized_types_to_string<boost::long_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+    test_optimized_types_to_string<unsigned __int64>();
+    test_optimized_types_to_string<__int64>();
+#endif
+
+#if !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+    test_optimized_types_to_string<float>();
+#endif
+    
+    test_optimized_types_to_string<std::string>();
+    test_optimized_types_to_string<char*>();
+    //test_optimized_types_to_string<char[5]>();
+    //test_optimized_types_to_string<char[1]>();
+    test_optimized_types_to_string<unsigned char*>();
+    //test_optimized_types_to_string<unsigned char[5]>();
+    //test_optimized_types_to_string<unsigned char[1]>();
+    test_optimized_types_to_string<signed char*>();
+    //test_optimized_types_to_string<signed char[5]>();
+    //test_optimized_types_to_string<signed char[1]>();
+    test_optimized_types_to_string<boost::array<char, 1> >();
+    test_optimized_types_to_string<boost::array<char, 5> >();
+    test_optimized_types_to_string<boost::array<unsigned char, 1> >();
+    test_optimized_types_to_string<boost::array<unsigned char, 5> >();
+    test_optimized_types_to_string<boost::array<signed char, 1> >();
+    test_optimized_types_to_string<boost::array<signed char, 5> >();
+    test_optimized_types_to_string<boost::iterator_range<char*> >();
+    test_optimized_types_to_string<boost::iterator_range<unsigned char*> >();
+    test_optimized_types_to_string<boost::iterator_range<signed char*> >();
+
+    test_optimized_types_to_string_const<boost::array<const char, 1> >();
+    test_optimized_types_to_string_const<boost::array<const char, 5> >();
+    test_optimized_types_to_string_const<boost::array<const unsigned char, 1> >();
+    test_optimized_types_to_string_const<boost::array<const unsigned char, 5> >();
+    test_optimized_types_to_string_const<boost::array<const signed char, 1> >();
+    test_optimized_types_to_string_const<boost::array<const signed char, 5> >();
+    test_optimized_types_to_string_const<boost::iterator_range<const char*> >();
+    test_optimized_types_to_string_const<boost::iterator_range<const unsigned char*> >();
+    test_optimized_types_to_string_const<boost::iterator_range<const signed char*> >();
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+    test_optimized_types_to_string<std::array<char, 1> >();
+    test_optimized_types_to_string<std::array<char, 5> >();
+    test_optimized_types_to_string<std::array<unsigned char, 1> >();
+    test_optimized_types_to_string<std::array<unsigned char, 5> >();
+    test_optimized_types_to_string<std::array<signed char, 1> >();
+    test_optimized_types_to_string<std::array<signed char, 5> >();
+    
+    test_optimized_types_to_string_const<std::array<const char, 1> >();
+    test_optimized_types_to_string_const<std::array<const char, 5> >();
+    test_optimized_types_to_string_const<std::array<const unsigned char, 1> >();
+    test_optimized_types_to_string_const<std::array<const unsigned char, 5> >();
+    test_optimized_types_to_string_const<std::array<const signed char, 1> >();
+    test_optimized_types_to_string_const<std::array<const signed char, 5> >();
+#endif
+}
+
+boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    boost::unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast traits tests");
+    suite->add(BOOST_TEST_CASE(&test_metafunctions));
+    return suite;
+}
+
@@ -0,0 +1,622 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Terje Sletteb and Kevlin Henney, 2005.
+//  Copyright Alexander Nasonov, 2006.
+//  Copyright Antony Polukhin, 2011-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).
+//
+// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
+
+//
+// We need this #define before any #includes: otherwise msvc will emit warnings
+// deep within std::string, resulting from our (perfectly legal) use of basic_string
+// with a custom traits class:
+//
+#define _SCL_SECURE_NO_WARNINGS
+
+#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/cstdint.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include <boost/type_traits/integral_promotion.hpp>
+#include <string>
+#include <vector>
+#include <algorithm> // std::transform
+#include <memory>
+
+#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
+    && !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
+#define LCAST_TEST_LONGLONG
+#endif
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+template<class CharT>
+struct my_traits : std::char_traits<CharT>
+{
+};
+
+template<class CharT>
+struct my_allocator : std::allocator<CharT>
+{
+};
+
+using namespace boost;
+
+void test_conversion_to_char();
+void test_conversion_to_int();
+void test_conversion_to_double();
+void test_conversion_to_bool();
+void test_conversion_with_nonconst_char();
+void test_conversion_to_string();
+void test_conversion_from_to_wchar_t_alias();
+void test_conversion_from_wchar_t();
+void test_conversion_to_wchar_t();
+void test_conversion_from_wstring();
+void test_conversion_to_wstring();
+void test_bad_lexical_cast();
+void test_no_whitespace_stripping();
+void test_volatile_types_conversions();
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+void test_traits();
+void test_wtraits();
+void test_allocator();
+void test_wallocator();
+#endif
+void test_char_types_conversions();
+void operators_overload_test();
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+void test_char16_conversions();
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+void test_char32_conversions();
+#endif
+void test_getting_pointer_to_function();
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test");
+    suite->add(BOOST_TEST_CASE(test_conversion_to_char));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_int));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_double));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
+    suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_string));
+    suite->add(BOOST_TEST_CASE(test_conversion_with_nonconst_char));
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
+    suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
+#endif
+    suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
+    suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
+    suite->add(BOOST_TEST_CASE(test_volatile_types_conversions));
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    suite->add(BOOST_TEST_CASE(&test_traits));
+    suite->add(BOOST_TEST_CASE(&test_wtraits));
+    suite->add(BOOST_TEST_CASE(&test_allocator));
+    suite->add(BOOST_TEST_CASE(&test_wallocator));
+#endif
+
+    suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
+    suite->add(BOOST_TEST_CASE(&operators_overload_test));
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+    suite->add(BOOST_TEST_CASE(&test_char16_conversions));
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+    suite->add(BOOST_TEST_CASE(&test_char32_conversions));
+#endif
+    suite->add(BOOST_TEST_CASE(&test_getting_pointer_to_function));
+
+    return suite;
+}
+
+void test_conversion_to_char()
+{
+    BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
+    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
+    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
+    BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
+    BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
+    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
+    BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
+    BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
+    BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
+    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
+    BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
+    BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
+    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
+    BOOST_CHECK_THROW(
+        lexical_cast<char>(std::string("")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<char>(std::string("Test")), bad_lexical_cast);
+}
+
+void test_conversion_to_int()
+{
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
+    BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
+    BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
+
+    BOOST_CHECK_EQUAL(
+        (std::numeric_limits<int>::max)(),
+        lexical_cast<int>((std::numeric_limits<int>::max)()));
+
+    BOOST_CHECK_EQUAL(
+        (std::numeric_limits<int>::min)(),
+        lexical_cast<int>((std::numeric_limits<int>::min)()));
+
+    BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
+
+    BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
+    BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
+    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(" 123"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
+    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(std::string("")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(std::string("Test")), bad_lexical_cast);
+}
+
+void test_conversion_with_nonconst_char()
+{
+    std::vector<char> buffer;
+    buffer.push_back('1');
+    buffer.push_back('\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer[0]), 1);
+
+    std::vector<unsigned char> buffer2;
+    buffer2.push_back('1');
+    buffer2.push_back('\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer2[0]), 1);
+
+    std::vector<unsigned char> buffer3;
+    buffer3.push_back('1');
+    buffer3.push_back('\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer3[0]), 1);
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    std::vector<wchar_t> buffer4;
+    buffer4.push_back(L'1');
+    buffer4.push_back(L'\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer4[0]), 1);
+#endif
+}
+
+void test_conversion_to_double()
+{
+    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
+    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>(1.234567890), std::numeric_limits<double>::epsilon());
+    BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>("1.234567890"), std::numeric_limits<double>::epsilon());
+    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE_FRACTION(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
+    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_THROW(
+        lexical_cast<double>(std::string("")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<double>(std::string("Test")), bad_lexical_cast);
+}
+
+void test_conversion_to_bool()
+{
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
+    BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
+    BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
+    BOOST_CHECK_THROW(lexical_cast<bool>(-123), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
+    BOOST_CHECK_THROW(lexical_cast<bool>(1234), bad_lexical_cast);
+#if !defined(_CRAYC)
+    // Looks like a bug in CRAY compiler (throws bad_lexical_cast)
+    // TODO: localize the bug and report it to developers.
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
+#endif
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
+    BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
+
+    BOOST_CHECK_THROW(lexical_cast<bool>(1.0001L), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(2), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(2u), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(-1), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(-2), bad_lexical_cast);
+
+
+    BOOST_CHECK_THROW(
+        lexical_cast<bool>(std::string("")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
+
+    BOOST_CHECK(lexical_cast<bool>("+1") == true );
+    BOOST_CHECK(lexical_cast<bool>("+0") == false );
+    BOOST_CHECK(lexical_cast<bool>("-0") == false );
+    BOOST_CHECK_THROW(lexical_cast<bool>("--0"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>("-+-0"), bad_lexical_cast);
+}
+
+void test_conversion_to_string()
+{
+    char buf[] = "hello";
+    char* str = buf;
+    BOOST_CHECK_EQUAL(str, lexical_cast<std::string>(str));
+    BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
+    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(' '));
+    BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
+    BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
+    BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
+    BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
+    BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
+    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
+    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
+    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
+    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
+    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
+    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
+}
+
+void test_conversion_from_to_wchar_t_alias()
+{
+    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
+    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
+    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
+    BOOST_CHECK_EQUAL(std::string("123"),
+        lexical_cast<std::string>(static_cast<unsigned short>(123)));
+    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
+    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
+}
+
+void test_conversion_from_wchar_t()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
+    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
+#endif
+
+    BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
+    BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
+    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
+#endif
+
+    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
+    BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
+    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
+#endif
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
+    BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
+#endif
+}
+
+void test_conversion_to_wchar_t()
+{
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
+    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
+    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>('1'));
+    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>('0'));
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
+    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
+    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
+    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
+    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
+    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
+    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
+    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
+    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
+    BOOST_CHECK_THROW(
+        lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
+#endif
+    BOOST_CHECK(true);
+}
+
+void test_conversion_from_wstring()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
+
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
+    BOOST_CHECK_THROW(
+        lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
+#endif
+    BOOST_CHECK(true);
+}
+
+void test_conversion_to_wstring()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    wchar_t buf[] = L"hello";
+    wchar_t* str = buf;
+    BOOST_CHECK(str == lexical_cast<std::wstring>(str));
+    BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
+    BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
+    BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
+    BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
+    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
+    BOOST_CHECK(L"A" == lexical_cast<std::wstring>('A'));
+#endif
+    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
+    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
+    BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
+    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
+    BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
+    BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
+#endif
+    BOOST_CHECK(true);
+}
+
+void test_bad_lexical_cast()
+{
+    try
+    {
+        lexical_cast<int>(std::string("Test"));
+
+        BOOST_CHECK(false); // Exception expected
+    }
+    catch(const bad_lexical_cast &e)
+    {
+        BOOST_CHECK(e.source_type() == typeid(std::string));
+        BOOST_CHECK(e.target_type() == typeid(int));
+    }
+}
+
+void test_no_whitespace_stripping()
+{
+    BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
+}
+
+void test_volatile_types_conversions()
+{
+    volatile int i1 = 100000;
+    BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i1));
+
+    volatile const int i2 = 100000;
+    BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i2));
+
+    volatile const long int i3 = 1000000;
+    BOOST_CHECK_EQUAL("1000000", boost::lexical_cast<std::string>(i3));
+}
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+void test_traits()
+{
+    typedef std::basic_string<char, my_traits<char> > my_string;
+
+    my_string const s("s");
+    BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
+    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
+    BOOST_CHECK(boost::lexical_cast<my_string>(-1) == "-1");
+}
+
+void test_wtraits()
+{
+    typedef std::basic_string<wchar_t, my_traits<wchar_t> > my_string;
+
+    my_string const s(L"s");
+    BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
+    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
+    //BOOST_CHECK(boost::lexical_cast<my_string>(-1) == L"-1");
+    // Commented out because gcc 3.3 doesn't support this:
+    // basic_ostream<wchar_t, my_traits<wchar_t> > o; o << -1;
+}
+
+void test_allocator()
+{
+// Following test cause compilation error on MSVC2012:
+// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
+// 
+// MSVC developer is notified about this issue
+#if !defined(_MSC_VER) || (_MSC_VER < 1700)
+    typedef std::basic_string< char
+                             , std::char_traits<char>
+                             , my_allocator<char>
+                             > my_string;
+
+    my_string s("s");
+    BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
+    BOOST_CHECK(boost::lexical_cast<std::string>(s) == "s");
+    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
+    BOOST_CHECK(boost::lexical_cast<my_string>(1) == "1");
+    BOOST_CHECK(boost::lexical_cast<my_string>("s") == s);
+    BOOST_CHECK(boost::lexical_cast<my_string>(std::string("s")) == s);
+#endif
+}
+
+void test_wallocator()
+{
+// Following test cause compilation error on MSVC2012:
+// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
+// 
+// MSVC developer is notified about this issue
+#if !defined(_MSC_VER) || (_MSC_VER < 1700)
+    typedef std::basic_string< wchar_t
+                             , std::char_traits<wchar_t>
+                             , my_allocator<wchar_t>
+                             > my_string;
+
+    my_string s(L"s");
+    BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
+    BOOST_CHECK(boost::lexical_cast<std::wstring>(s) == L"s");
+    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
+    BOOST_CHECK(boost::lexical_cast<my_string>(1) == L"1");
+    BOOST_CHECK(boost::lexical_cast<my_string>(L"s") == s);
+    BOOST_CHECK(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
+#endif
+}
+
+#endif
+
+
+void test_char_types_conversions()
+{
+    const char c_arr[]            = "Test array of chars";
+    const unsigned char uc_arr[]  = "Test array of chars";
+    const signed char sc_arr[]    = "Test array of chars";
+
+    BOOST_CHECK(boost::lexical_cast<std::string>(c_arr) == std::string(c_arr));
+    BOOST_CHECK(boost::lexical_cast<std::string>(uc_arr) == std::string(c_arr));
+    BOOST_CHECK(boost::lexical_cast<std::string>(sc_arr) == std::string(c_arr));
+
+    BOOST_CHECK(boost::lexical_cast<char>(c_arr[0]) == c_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<char>(uc_arr[0]) == c_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<char>(sc_arr[0]) == c_arr[0]);
+
+    BOOST_CHECK(boost::lexical_cast<unsigned char>(c_arr[0]) == uc_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<unsigned char>(uc_arr[0]) == uc_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<unsigned char>(sc_arr[0]) == uc_arr[0]);
+
+    BOOST_CHECK(boost::lexical_cast<signed char>(c_arr[0]) == sc_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<signed char>(uc_arr[0]) == sc_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<signed char>(sc_arr[0]) == sc_arr[0]);
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    const wchar_t wc_arr[]=L"Test array of chars";
+
+    BOOST_CHECK(boost::lexical_cast<std::wstring>(wc_arr) == std::wstring(wc_arr));
+    BOOST_CHECK(boost::lexical_cast<wchar_t>(wc_arr[0]) == wc_arr[0]);
+
+#endif
+}
+
+
+
+struct foo_operators_test
+{
+  foo_operators_test() : f(2) {}
+  int f;
+};
+
+template <typename OStream>
+OStream& operator<<(OStream& ostr, const foo_operators_test& foo)
+{
+  ostr << foo.f;
+  return ostr;
+}
+
+template <typename IStream>
+IStream& operator>>(IStream& istr, foo_operators_test& foo)
+{
+  istr >> foo.f;
+  return istr;
+}
+
+void operators_overload_test()
+{
+    foo_operators_test foo;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(foo), "2");
+    BOOST_CHECK_EQUAL((boost::lexical_cast<foo_operators_test>("2")).f, 2);
+
+    // Must compile
+    (void)boost::lexical_cast<foo_operators_test>(foo);
+}
+
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+void test_char16_conversions()
+{
+    BOOST_CHECK(u"100" == lexical_cast<std::u16string>(u"100"));
+    BOOST_CHECK(u"1" == lexical_cast<std::u16string>(u'1'));
+}
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+void test_char32_conversions()
+{
+    BOOST_CHECK(U"100" == lexical_cast<std::u32string>(U"100"));
+    BOOST_CHECK(U"1" == lexical_cast<std::u32string>(U'1'));
+}
+#endif
+
+void test_getting_pointer_to_function()
+{
+    // Just checking that &lexical_cast<To, From> is not ambiguous
+    typedef char char_arr[4];    
+    typedef int(*f1)(const char_arr&);
+    f1 p1 = &boost::lexical_cast<int, char_arr>;
+    BOOST_CHECK(p1);
+
+    typedef int(*f2)(const std::string&);
+    f2 p2 = &boost::lexical_cast<int, std::string>;
+    BOOST_CHECK(p2);
+
+    typedef std::string(*f3)(const int&);
+    f3 p3 = &boost::lexical_cast<std::string, int>;
+    BOOST_CHECK(p3);
+
+    std::vector<int> values;
+    std::vector<std::string> ret;
+    std::transform(values.begin(), values.end(), ret.begin(), boost::lexical_cast<std::string, int>);
+}
+
+
@@ -0,0 +1,23 @@
+//  //  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013.
+//
+//  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/lexical_cast.hpp>
+#include <boost/type.hpp>
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+int test_main(int, char*[])
+{
+    boost::lexical_cast<char*>("Hello");
+    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
+    return 0;
+}
+
@@ -0,0 +1,40 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011.
+//
+//  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>
+
+#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;
+}
+
+
@@ -0,0 +1,48 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011.
+//
+//  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>
+using namespace boost;
+
+void test_typedefed_wchar_t_runtime()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+#ifdef BOOST_MSVC
+    BOOST_STATIC_ASSERT((boost::is_same<wchar_t, unsigned short>::value));
+
+
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(L'A'), 65);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(L'B'), 66);
+
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(L"65"), 65);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(L"66"), 66);
+#endif
+#endif
+    BOOST_CHECK(1);
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast typedefed wchar_t runtime test");
+    suite->add(BOOST_TEST_CASE(&test_typedefed_wchar_t_runtime));
+
+    return suite;
+}
@@ -0,0 +1,67 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Alexander Nasonov, 2007.
+//
+//  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).
+//
+// This tests now must pass on vc8, because lexical_cast
+// implementation has changed and it does not use stringstream for casts
+// to integral types
+
+#include <boost/config.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+
+using namespace boost;
+
+// See also test_conversion_from_string_to_integral(CharT)
+// in libs/conversion/lexical_cast_test.cpp
+template<class T, class CharT>
+void test_too_long_number(CharT zero)
+{
+    typedef std::numeric_limits<T> limits;
+
+    std::basic_string<CharT> s;
+
+    std::basic_ostringstream<CharT> o;
+    o << (limits::max)() << zero;
+    s = o.str();
+    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+    s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
+    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+
+    if(limits::is_signed)
+    {
+        std::basic_ostringstream<CharT> o;
+        o << (limits::min)() << zero;
+        s = o.str();
+        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+        s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
+        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+    }
+}
+
+void test_vc8_bug()
+{
+    test_too_long_number<boost::intmax_t>('0');
+    test_too_long_number<boost::uintmax_t>('0');
+#if !defined(BOOST_LCAST_NO_WCHAR_T)
+    test_too_long_number<boost::intmax_t>(L'0');
+    test_too_long_number<boost::uintmax_t>(L'0');
+#endif
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast vc8 bug unit test");
+    suite->add(BOOST_TEST_CASE(test_vc8_bug));
+    return suite;
+}
@@ -0,0 +1,137 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011-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>
+
+using namespace boost;
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+template <class CharT>
+void test_impl(const CharT* wc_arr)
+{
+    typedef CharT                       wide_char;
+    typedef std::basic_string<CharT>    wide_string;
+    const char c_arr[]            = "Test array of chars";
+    const unsigned char uc_arr[]  = "Test array of chars";
+    const signed char sc_arr[]    = "Test array of chars";
+
+    // Following tests depend on realization of std::locale
+    // and pass for popular compilers and STL realizations
+    BOOST_CHECK(boost::lexical_cast<wide_char>(c_arr[0]) == wc_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<wide_string>(c_arr) == wide_string(wc_arr));
+
+    BOOST_CHECK(boost::lexical_cast<wide_string>(sc_arr) == wide_string(wc_arr) );
+    BOOST_CHECK(boost::lexical_cast<wide_string>(uc_arr) == wide_string(wc_arr) );
+
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wide_char>(uc_arr[0]), wc_arr[0]);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wide_char>(sc_arr[0]), wc_arr[0]);
+}
+
+
+void test_char_types_conversions_wchar_t()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    test_impl(L"Test array of chars");
+    wchar_t c = boost::detail::lcast_char_constants<wchar_t>::zero;
+    BOOST_CHECK_EQUAL(L'0', c);
+
+    c = boost::detail::lcast_char_constants<wchar_t>::minus;
+    BOOST_CHECK_EQUAL(L'-', c);
+
+    c = boost::detail::lcast_char_constants<wchar_t>::plus;
+    BOOST_CHECK_EQUAL(L'+', c);
+
+    c = boost::detail::lcast_char_constants<wchar_t>::lowercase_e;
+    BOOST_CHECK_EQUAL(L'e', c);
+
+    c = boost::detail::lcast_char_constants<wchar_t>::capital_e;
+    BOOST_CHECK_EQUAL(L'E', c);
+
+    c = boost::detail::lcast_char_constants<wchar_t>::c_decimal_separator;
+    BOOST_CHECK_EQUAL(L'.', c);
+#endif
+
+    BOOST_CHECK(true);
+}
+
+void test_char_types_conversions_char16_t()
+{
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+    test_impl(u"Test array of chars");
+    char16_t c = boost::detail::lcast_char_constants<char16_t>::zero;
+    BOOST_CHECK_EQUAL(u'0', c);
+
+    c = boost::detail::lcast_char_constants<char16_t>::minus;
+    BOOST_CHECK_EQUAL(u'-', c);
+
+    c = boost::detail::lcast_char_constants<char16_t>::plus;
+    BOOST_CHECK_EQUAL(u'+', c);
+
+    c = boost::detail::lcast_char_constants<char16_t>::lowercase_e;
+    BOOST_CHECK_EQUAL(u'e', c);
+
+    c = boost::detail::lcast_char_constants<char16_t>::capital_e;
+    BOOST_CHECK_EQUAL(u'E', c);
+
+    c = boost::detail::lcast_char_constants<char16_t>::c_decimal_separator;
+    BOOST_CHECK_EQUAL(u'.', c);
+#endif
+
+    BOOST_CHECK(true);
+}
+
+void test_char_types_conversions_char32_t()
+{
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+    test_impl(U"Test array of chars");
+    char32_t c = boost::detail::lcast_char_constants<char32_t>::zero;
+    BOOST_CHECK_EQUAL(U'0', c);
+
+    c = boost::detail::lcast_char_constants<char32_t>::minus;
+    BOOST_CHECK_EQUAL(U'-', c);
+
+    c = boost::detail::lcast_char_constants<char32_t>::plus;
+    BOOST_CHECK_EQUAL(U'+', c);
+
+    c = boost::detail::lcast_char_constants<char32_t>::lowercase_e;
+    BOOST_CHECK_EQUAL(U'e', c);
+
+    c = boost::detail::lcast_char_constants<char32_t>::capital_e;
+    BOOST_CHECK_EQUAL(U'E', c);
+
+    c = boost::detail::lcast_char_constants<char32_t>::c_decimal_separator;
+    BOOST_CHECK_EQUAL(U'.', c);
+#endif
+
+    BOOST_CHECK(true);
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast char => wide characters unit test (widening test)");
+    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_wchar_t));
+    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_char16_t));
+    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_char32_t));
+
+    return suite;
+}
@@ -0,0 +1,101 @@
+//  boost utility cast test program  -----------------------------------------//
+
+//  (C) Copyright Beman Dawes, Dave Abrahams 1999. 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)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//   28 Set 04  factored out numeric_cast<> test (Fernando Cacciola)
+//   20 Jan 01  removed use of <limits> for portability to raw GCC (David Abrahams)
+//   28 Jun 00  implicit_cast removed (Beman Dawes)
+//   30 Aug 99  value_cast replaced by numeric_cast
+//    3 Aug 99  Initial Version
+
+#include <iostream>
+#include <climits>
+#include <cfloat>   // for DBL_MAX (Peter Schmid)
+#include <boost/cast.hpp>
+
+#include "boost/test/minimal.hpp"
+
+#  if SCHAR_MAX == LONG_MAX
+#      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
+#  endif
+
+using namespace boost;
+using std::cout;
+
+
+int test_main( int , char * [] )
+{
+
+#   ifdef NDEBUG
+        cout << "NDEBUG is defined\n";
+#   else
+        cout << "NDEBUG is not defined\n";
+#   endif
+
+    cout << "\nBeginning tests...\n";
+
+//  test implicit_cast and numeric_cast  -------------------------------------//
+
+    //  tests which should succeed
+    long small_value = 1;
+    long small_negative_value = -1;
+    long large_value = LONG_MAX;
+    long large_negative_value = LONG_MIN;
+    signed char c = 0;
+
+    c = static_cast<signed char>(large_value);
+
+    c = numeric_cast<signed char>( small_value );
+    BOOST_CHECK( c == 1 );
+    c = 0;
+    c = numeric_cast<signed char>( small_value );
+    BOOST_CHECK( c == 1 );
+    c = 0;
+    c = numeric_cast<signed char>( small_negative_value );
+    BOOST_CHECK( c == -1 );
+
+    // These tests courtesy of Joe R NWP Swatosh<joe.r.swatosh@usace.army.mil>
+    BOOST_CHECK( 0.0f == numeric_cast<float>( 0.0 ) );
+    BOOST_CHECK( 0.0 == numeric_cast<double>( 0.0 ) );
+
+    //  tests which should result in errors being detected
+
+    bool caught_exception = false;
+    try { c = numeric_cast<signed char>( large_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
+    BOOST_CHECK ( caught_exception );
+
+    caught_exception = false;
+    try { c = numeric_cast<signed char>( large_negative_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
+    BOOST_CHECK ( caught_exception );
+
+    unsigned long ul;
+    caught_exception = false;
+    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
+    BOOST_CHECK ( caught_exception );
+
+    caught_exception = false;
+    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
+    BOOST_CHECK ( caught_exception );
+
+    caught_exception = false;
+    try { numeric_cast<int>( DBL_MAX ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
+    BOOST_CHECK ( caught_exception );
+
+    (void)ul; // Supressing GCC warning about set but unused wariable
+    return 0 ;
+}