mirror of
https://github.com/boostorg/conversion.git
synced 2026-08-06 13:34:14 +02:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 nobody
|
795785cfa7 |
@@ -1,90 +1,59 @@
|
||||
<!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">
|
||||
|
||||
<title>Header boost/cast.hpp Documentation</title>
|
||||
</head>
|
||||
<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>
|
||||
|
||||
<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>
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<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
|
||||
&<code>dynamic_cast<T&>(*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<Derived>(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 {
|
||||
<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 <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
|
||||
<b>Y</b> 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 <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. <b> </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. 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. It must also be used for crosscasts. It does an assert(
|
||||
dynamic_cast<Derived>(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. [See ISO Std 3.2]</p>
|
||||
<p>The C++ built-in <b>dynamic_cast</b> 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 <class Derived, class Base>
|
||||
inline Derived polymorphic_cast(Base* x);
|
||||
@@ -96,14 +65,11 @@ inline Derived polymorphic_downcast(Base* x);
|
||||
// Effects: assert( dynamic_cast<Derived>(x) == x );
|
||||
// Returns: static_cast<Derived>(x)
|
||||
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
<h3>polymorphic_downcast example</h3>
|
||||
|
||||
<blockquote>
|
||||
<pre>#include <boost/cast.hpp>
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<h3>polymorphic_downcast example</h3>
|
||||
<blockquote>
|
||||
<pre>#include <boost/cast.hpp>
|
||||
...
|
||||
class Fruit { public: virtual ~Fruit(){}; ... };
|
||||
class Banana : public Fruit { ... };
|
||||
@@ -111,30 +77,69 @@ class Banana : public Fruit { ... };
|
||||
void f( Fruit * fruit ) {
|
||||
// ... logic which leads us to believe it is a Banana
|
||||
Banana * banana = boost::polymorphic_downcast<Banana*>(fruit);
|
||||
...
|
||||
</pre>
|
||||
</blockquote>
|
||||
...</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<>::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 {
|
||||
|
||||
<h3>History</h3>
|
||||
class bad_numeric_cast : public std::bad_cast {...};
|
||||
|
||||
<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>
|
||||
template<typename Target, typename Source>
|
||||
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<Target>(arg)
|
||||
|
||||
<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>
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<h3>numeric_cast example</h3>
|
||||
<blockquote>
|
||||
<pre>#include <boost/cast.hpp>
|
||||
using namespace boost::cast;
|
||||
|
||||
<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 "as is" without express
|
||||
or implied warranty, and with no claim as to its suitability for any
|
||||
purpose.</p>
|
||||
</body>
|
||||
</html>
|
||||
void ariane(double vx)
|
||||
{
|
||||
...
|
||||
unsigned short dx = numeric_cast<unsigned short>(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 "The C++
|
||||
Programming Language".<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 <!--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 "as is" without express or
|
||||
implied warranty, and with no claim as to its suitability for any purpose.</p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
||||
+76
-14
@@ -1,13 +1,14 @@
|
||||
// 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)
|
||||
// (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
|
||||
// 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
|
||||
@@ -15,12 +16,11 @@
|
||||
|
||||
#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
|
||||
# endif
|
||||
|
||||
using namespace boost;
|
||||
using std::cout;
|
||||
@@ -28,34 +28,39 @@ 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";
|
||||
cout << "\nBeginning tests...\n";
|
||||
|
||||
// test polymorphic_cast ---------------------------------------------------//
|
||||
|
||||
|
||||
// tests which should succeed
|
||||
Base * base = new Derived;
|
||||
Base2 * base2 = 0;
|
||||
@@ -85,6 +90,63 @@ int main( int argc, char * argv[] )
|
||||
// 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;
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
# 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
|
||||
;
|
||||
|
||||
@@ -1,860 +0,0 @@
|
||||
[library Boost.Lexical_Cast
|
||||
[quickbook 1.5]
|
||||
[version 1.0]
|
||||
[copyright 2000-2005 Kevlin Henney]
|
||||
[copyright 2006-2010 Alexander Nasonov]
|
||||
[copyright 2011-2012 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]
|
||||
The following example treats command line arguments as a sequence of numeric data:
|
||||
``
|
||||
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(bad_lexical_cast &)
|
||||
{
|
||||
args.push_back(0);
|
||||
}
|
||||
}
|
||||
...
|
||||
}
|
||||
``
|
||||
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));
|
||||
}
|
||||
``
|
||||
Following example converts some number and puts it to file:
|
||||
``
|
||||
int i;
|
||||
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>(i); // No dynamic memory allocation
|
||||
puts(buffer.begin(), file);
|
||||
``
|
||||
[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);
|
||||
}
|
||||
``
|
||||
|
||||
[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.
|
||||
|
||||
The requirements on the argument and result types 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`, `char16_t` or `char32_t`. Wide-character streaming is currently detected for:
|
||||
|
||||
* Single character: `wchar_t`, `char16_t`, `char32_t`
|
||||
* Arrays of characters: `wchar_t *`, `char16_t *`, `char32_t *`, `const wchar_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]
|
||||
|
||||
[/ Commenting out bad advise (this will break the ability to get correct function pointers via &lexical_cast<Target, Source>)
|
||||
[section Tuning classes for fast lexical conversions]
|
||||
Because of `boost::lexical_cast` optimizations for `boost::iterator_range<character_type*>`, it is possibile to make very fast lexical conversions for non zero terminated strings, substrings and user-defined classes.
|
||||
|
||||
Consider the following example:
|
||||
``
|
||||
class example_class {
|
||||
char non_zero_terminated_data[10];
|
||||
std::size_t data_length;
|
||||
|
||||
public:
|
||||
example_class();
|
||||
void fill_data();
|
||||
|
||||
const char* data() const {
|
||||
return non_zero_terminated_data;
|
||||
}
|
||||
|
||||
std::size_t size() const {
|
||||
return data_length;
|
||||
}
|
||||
};
|
||||
|
||||
inline std::ostream& operator << (std::ostream& ostr, const example_class& rhs) {
|
||||
return ostr << boost::make_iterator_range(rhs.data(), rhs.data() + rhs.size());
|
||||
}
|
||||
``
|
||||
|
||||
This is a good generic solution for most use cases.
|
||||
But we can make it even faster for some performance critical applications. During conversion, we loose speed at:
|
||||
|
||||
* `std::ostream` construction (it makes some heap allocations)
|
||||
* `operator <<` (it copyies one by one all the symbols to an instance of `std::ostream`)
|
||||
* `std::ostream` destruction (it makes some heap deallocations)
|
||||
|
||||
We can avoid all of this, by specifieng an overload for `boost::lexical_cast`:
|
||||
``
|
||||
namespace boost {
|
||||
template <class OutT>
|
||||
OutT lexical_cast(const example_class& rhs) {
|
||||
return boost::lexical_cast<OutT>(
|
||||
boost::make_iterator_range(rhs.data(), rhs.data() + rhs.size())
|
||||
);
|
||||
}
|
||||
}
|
||||
``
|
||||
Now `boost::lexical_cast<some_type>(example_class_instance)` conversions won't copy data and construct heavy STL stream objects. See [link boost_lexical_cast.performance Performance] section for info on `boost::iterator_range` conversion performance.
|
||||
[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>>` conform to the standard.
|
||||
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. For example, if you whant to convert to `int` two characters from a string `str`, you shall write `lexacal_cast<int>(make_iterator_range(str.c_str(), str.c_str() + 2));`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Changes]
|
||||
|
||||
* [*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]
|
||||
|
||||
|
||||
[/ END of section, generated by performance measuring program ]
|
||||
[endsect]
|
||||
|
||||
+260
-25
@@ -1,18 +1,14 @@
|
||||
// boost cast.hpp header file ----------------------------------------------//
|
||||
|
||||
// (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)
|
||||
// (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/libs/conversion for Documentation.
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 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
|
||||
// vc-stlport.
|
||||
@@ -27,14 +23,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,18 +40,19 @@
|
||||
#define BOOST_CAST_HPP
|
||||
|
||||
# include <boost/config.hpp>
|
||||
# include <boost/assert.hpp>
|
||||
# include <cassert>
|
||||
# include <typeinfo>
|
||||
# include <boost/type.hpp>
|
||||
# include <boost/limits.hpp>
|
||||
# include <boost/detail/select_type.hpp>
|
||||
# ifndef BOOST_NO_LIMITS
|
||||
# include <limits>
|
||||
# endif
|
||||
|
||||
// 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 < 1300
|
||||
# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // 1200 = VC6
|
||||
# define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
|
||||
# else
|
||||
# define BOOST_EXPLICIT_DEFAULT_TARGET
|
||||
@@ -69,7 +66,7 @@ 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>
|
||||
@@ -82,26 +79,264 @@ namespace boost
|
||||
|
||||
// polymorphic_downcast ----------------------------------------------------//
|
||||
|
||||
// BOOST_ASSERT() checked polymorphic downcast. Crosscasts prohibited.
|
||||
// assert() checked polymorphic downcast. Crosscasts prohibited.
|
||||
|
||||
// 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.
|
||||
// WARNING: Because this cast uses assert(), it violates the One Definition
|
||||
// Rule if NDEBUG is inconsistently defined across translation units.
|
||||
|
||||
// Contributed by Dave Abrahams
|
||||
|
||||
template <class Target, class Source>
|
||||
inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
|
||||
{
|
||||
BOOST_ASSERT( dynamic_cast<Target>(x) == x ); // detect logic error
|
||||
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
|
||||
|
||||
# ifndef BOOST_NO_LIMITS
|
||||
// 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();
|
||||
}
|
||||
};
|
||||
# endif // BOOST_NO_LIMITS
|
||||
|
||||
# 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)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS
|
||||
// typedefs abbreviating respective trait classes
|
||||
typedef std::numeric_limits<Source> arg_traits;
|
||||
typedef detail::fixed_numeric_limits<Target> result_traits;
|
||||
#endif
|
||||
|
||||
#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
|
||||
|
||||
@@ -1,184 +0,0 @@
|
||||
// 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
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
// 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
|
||||
+37
-2417
File diff suppressed because it is too large
Load Diff
@@ -3,14 +3,14 @@
|
||||
<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 5.0">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Boost Conversion Library</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<h1><img border="0" src="../../boost.png" align="center" width="277" height="86">Boost
|
||||
<h1><img border="0" src="../../c++boost.gif" align="center" width="277" height="86">Boost
|
||||
Conversion Library</h1>
|
||||
|
||||
<p>The Conversion Library improves program safety and clarity by performing
|
||||
@@ -22,17 +22,18 @@ supplied by several headers:</p>
|
||||
<ul>
|
||||
<li>The <a href="cast.htm">boost/cast</a> header provides <b>polymorphic_cast<></b>
|
||||
and <b>polymorphic_downcast<></b> to perform safe casting between
|
||||
polymorphic types.<br>
|
||||
polymorphic types, and <b> numeric_cast</b><i><></i> to perform safe casting
|
||||
between numeric types.<br>
|
||||
</li>
|
||||
<li>The <a href="../../doc/html/boost_lexical_cast.html">boost/lexical_cast</a> header provides <b>lexical_cast<></b>
|
||||
<li>The <a href="lexical_cast.htm">boost/lexical_cast</a> header provides <b>lexical_cast<></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 -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348" -->
|
||||
S-Format="%d %B, %Y" startspan -->06 January, 2001<!--webbot bot="Timestamp" endspan i-checksum="38320" -->
|
||||
</p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
</html>
|
||||
+237
-11
@@ -1,16 +1,242 @@
|
||||
|
||||
<!--
|
||||
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)
|
||||
-->
|
||||
|
||||
<!doctype html public "-//W3C//DTD HTML Transitional 4.0//EN">
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/boost_lexical_cast.html">
|
||||
<title>lexical_cast</title>
|
||||
<meta name="author" content="Kevlin Henney, mailto:kevlin@curbralan.com">
|
||||
<meta name="generator" content="Microsoft FrontPage 4.0">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/boost_lexical_cast.html">../../doc/html/boost_lexical_cast.html</a>
|
||||
|
||||
<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<short> args;
|
||||
|
||||
while(*++argv)
|
||||
{
|
||||
try
|
||||
{
|
||||
args.push_back(lexical_cast<short>(*argv));
|
||||
}
|
||||
catch(bad_lexical_cast &)
|
||||
{
|
||||
args.push_back(0);
|
||||
}
|
||||
}
|
||||
...
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
The following example uses numeric data in a string expression:
|
||||
<blockquote>
|
||||
<pre>
|
||||
void log_message(const std::string &);
|
||||
|
||||
void log_errno(int yoko)
|
||||
{
|
||||
log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
<hr>
|
||||
<h2><a name="synopsis">Synopsis</a></h2>
|
||||
|
||||
Library features defined in <a href="../../boost/lexical_cast.hpp"><code>"boost/lexical_cast.hpp"</code></a>:
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class <a href="#bad_lexical_cast">bad_lexical_cast</a>;
|
||||
template<typename Target, typename Source>
|
||||
Target <a href="#lexical_cast">lexical_cast</a>(Source arg);
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
Test harness defined in <a href="lexical_cast_test.cpp"><code>"lexical_cast_test.cpp"</code></a>.
|
||||
<p>
|
||||
|
||||
<hr>
|
||||
<h2><a name="lexical_cast"><code>lexical_cast</code></a></h2>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
template<typename Target, typename Source>
|
||||
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<<</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>></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><strstream></code> is used in
|
||||
preference to the standard <code><sstream></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>© Copyright Kevlin Henney, 2000</i></small></div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
+118
-546
@@ -1,577 +1,149 @@
|
||||
// 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.
|
||||
// boost lexical_cast_test.cpp program -------------------------------------//
|
||||
|
||||
//
|
||||
// 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
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
#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
|
||||
// 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 <boost/cstdint.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/test/floating_point_comparison.hpp>
|
||||
|
||||
#include <boost/type_traits/integral_promotion.hpp>
|
||||
#include "test.hpp"
|
||||
#include <complex>
|
||||
#include <iostream>
|
||||
#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
|
||||
|
||||
template<class CharT>
|
||||
struct my_traits : std::char_traits<CharT>
|
||||
{
|
||||
};
|
||||
|
||||
template<class CharT>
|
||||
struct my_allocator : std::allocator<CharT>
|
||||
{
|
||||
};
|
||||
|
||||
using namespace boost;
|
||||
using namespace std;
|
||||
|
||||
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_to_pointer();
|
||||
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();
|
||||
#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_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
void test_char16_conversions();
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
void test_char32_conversions();
|
||||
#endif
|
||||
typedef test::test<const char *, void (*)()> test_case;
|
||||
typedef const test_case * test_case_iterator;
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
extern const test_case_iterator begin, end;
|
||||
|
||||
int main()
|
||||
{
|
||||
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_pointer));
|
||||
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));
|
||||
#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_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
suite->add(BOOST_TEST_CASE(&test_char16_conversions));
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
suite->add(BOOST_TEST_CASE(&test_char32_conversions));
|
||||
#endif
|
||||
|
||||
return suite;
|
||||
test::tester<test_case_iterator> test_suite(begin, end);
|
||||
return test_suite() ? EXIT_SUCCESS : EXIT_FAILURE;
|
||||
}
|
||||
|
||||
void test_conversion_to_char()
|
||||
void test_to_string()
|
||||
{
|
||||
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);
|
||||
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_conversion_to_int()
|
||||
void test_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);
|
||||
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_conversion_with_nonconst_char()
|
||||
void test_to_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
|
||||
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_conversion_to_double()
|
||||
void test_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);
|
||||
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_conversion_to_bool()
|
||||
void test_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_EQUAL(false, lexical_cast<bool>(0.0));
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
|
||||
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);
|
||||
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\"");
|
||||
}
|
||||
|
||||
void test_conversion_to_string()
|
||||
const test_case test_cases[] =
|
||||
{
|
||||
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_to_pointer()
|
||||
{
|
||||
BOOST_CHECK_THROW(lexical_cast<char *>("Test"), bad_lexical_cast);
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
#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()
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
void test_wallocator()
|
||||
{
|
||||
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
|
||||
|
||||
|
||||
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;
|
||||
{ "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 }
|
||||
};
|
||||
|
||||
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_CHAR16_T) && !defined(BOOST_NO_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_CHAR16_T) && !defined(BOOST_NO_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
|
||||
|
||||
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.
|
||||
|
||||
@@ -1,100 +0,0 @@
|
||||
// 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 argc, char * argv[] )
|
||||
{
|
||||
|
||||
# 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 = large_value; // see if compiler generates warning
|
||||
|
||||
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 );
|
||||
|
||||
return 0 ;
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
#==============================================================================
|
||||
# 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) ;
|
||||
|
||||
@@ -1,369 +0,0 @@
|
||||
// (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;
|
||||
}
|
||||
|
||||
|
||||
@@ -44,7 +44,7 @@ namespace test // failure exception used to indicate checked test failures
|
||||
}
|
||||
|
||||
// std::~string has no exception-specification (could throw anything),
|
||||
// but we need to be compatible with std::~exception's empty one
|
||||
// but we need to be compatible with std::~exception's empty one
|
||||
// see std::15.4p13 and std::15.4p3
|
||||
~failure() throw()
|
||||
{
|
||||
@@ -303,6 +303,10 @@ namespace test // tester is the driver class for a sequence of tests
|
||||
|
||||
// Copyright Kevlin Henney, 2000. All rights reserved.
|
||||
//
|
||||
// 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)
|
||||
// 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.
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
# Copyright (C) 2001-2003 Douglas Gregor
|
||||
# Copyright (C) 2011-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)
|
||||
#
|
||||
|
||||
import testing ;
|
||||
import feature ;
|
||||
|
||||
project
|
||||
: requirements
|
||||
<library>/boost/test//boost_unit_test_framework
|
||||
<link>static
|
||||
<toolset>gcc-4.8:<define>BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
;
|
||||
|
||||
# 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 ]
|
||||
[ 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:<cflags>-fno-exceptions
|
||||
<toolset>gcc-4.4:<cflags>-fno-exceptions
|
||||
<toolset>gcc-4.5:<cflags>-fno-exceptions
|
||||
<toolset>gcc-4.6:<cflags>-fno-exceptions
|
||||
<toolset>gcc-4.7:<cflags>-fno-exceptions
|
||||
]
|
||||
[ run lexical_cast_iterator_range_test.cpp ]
|
||||
[ run lexical_cast_arrays_test.cpp ]
|
||||
[ run lexical_cast_integral_types_test.cpp ]
|
||||
;
|
||||
|
||||
@@ -1,38 +0,0 @@
|
||||
// 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();
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
// 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.
|
||||
return 0;
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
// 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");
|
||||
}
|
||||
|
||||
@@ -1,367 +0,0 @@
|
||||
// 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;
|
||||
|
||||
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.begin(), ethalon);
|
||||
const arr_type res2 = lexical_cast<arr_type>(val);
|
||||
BOOST_CHECK_EQUAL(res2.begin(), 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.begin()), ethalon);
|
||||
const uarr_type res2 = lexical_cast<uarr_type>(val);
|
||||
BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), 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.begin()), ethalon);
|
||||
const sarr_type res2 = lexical_cast<sarr_type>(val);
|
||||
BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), 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.begin() == wethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const warr_type res = lexical_cast<warr_type>(val);
|
||||
BOOST_CHECK(res.begin() == wethalon);
|
||||
}
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
|
||||
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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.begin() == u16ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const u16arr_type res = lexical_cast<u16arr_type>(val);
|
||||
BOOST_CHECK(res.begin() == u16ethalon);
|
||||
}
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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.begin() == u32ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const u32arr_type res = lexical_cast<u32arr_type>(val);
|
||||
BOOST_CHECK(res.begin() == 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.begin(), ethalon);
|
||||
const arr_type res2 = lexical_cast<arr_type>(val);
|
||||
BOOST_CHECK_EQUAL(res2.begin(), 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.begin()), ethalon);
|
||||
const uarr_type res2 = lexical_cast<uarr_type>(val);
|
||||
BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), 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.begin()), ethalon);
|
||||
const sarr_type res2 = lexical_cast<sarr_type>(val);
|
||||
BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), 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.begin() == wethalon);
|
||||
warr_type res3 = lexical_cast<warr_type>(wethalon);
|
||||
BOOST_CHECK(res3.begin() == wethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const warr_type res = lexical_cast<warr_type>(val);
|
||||
BOOST_CHECK(res.begin() == wethalon);
|
||||
const warr_type res3 = lexical_cast<warr_type>(wethalon);
|
||||
BOOST_CHECK(res3.begin() == wethalon);
|
||||
}
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
|
||||
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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.begin() == u16ethalon);
|
||||
#endif
|
||||
|
||||
u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
|
||||
BOOST_CHECK(res3.begin() == u16ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
const u16arr_type res = lexical_cast<u16arr_type>(val);
|
||||
BOOST_CHECK(res.begin() == u16ethalon);
|
||||
#endif
|
||||
const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
|
||||
BOOST_CHECK(res3.begin() == u16ethalon);
|
||||
}
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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.begin() == u32ethalon);
|
||||
#endif
|
||||
u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
|
||||
BOOST_CHECK(res3.begin() == u32ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
const u32arr_type res = lexical_cast<u32arr_type>(val);
|
||||
BOOST_CHECK(res.begin() == u32ethalon);
|
||||
#endif
|
||||
const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
|
||||
BOOST_CHECK(res3.begin() == u32ethalon);
|
||||
}
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
|
||||
#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()
|
||||
{
|
||||
#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_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
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
{
|
||||
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
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
{
|
||||
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()
|
||||
{
|
||||
#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
|
||||
testing_generic_array_input_conversion<std::array>();
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(true);
|
||||
}
|
||||
|
||||
@@ -1,83 +0,0 @@
|
||||
// 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_CHAR16_T) && !defined(BOOST_NO_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_CHAR32_T) && !defined(BOOST_NO_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
|
||||
}
|
||||
@@ -1,165 +0,0 @@
|
||||
// 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);
|
||||
BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_empty_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_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_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;
|
||||
}
|
||||
@@ -1,515 +0,0 @@
|
||||
// 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 is in interval [base_value-epsilon, base_value+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);
|
||||
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()));
|
||||
|
||||
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()));
|
||||
|
||||
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 fllowing 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);
|
||||
|
||||
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
|
||||
|
||||
#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() \
|
||||
);
|
||||
|
||||
/*
|
||||
* 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()
|
||||
{
|
||||
test_conversion_from_to_float<long double>();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,201 +0,0 @@
|
||||
// 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()
|
||||
{
|
||||
test_inf_nan_templated<long double >();
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
@@ -1,539 +0,0 @@
|
||||
// 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 <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
|
||||
|
||||
|
||||
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
|
||||
|
||||
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>();
|
||||
test_conversion_from_integral_to_string<T>('0');
|
||||
test_conversion_from_string_to_integral<T>('0');
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
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()
|
||||
{
|
||||
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_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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 = "160000000000000000000";
|
||||
std::string must_owerflow_negative_str = "-160000000000000000000";
|
||||
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';
|
||||
}
|
||||
|
||||
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
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,217 +0,0 @@
|
||||
// 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
|
||||
|
||||
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<unsigned int>(rng), 1u);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<short>(rng), 1);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng), 1u);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<long int>(rng), 1);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng), 1u);
|
||||
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
BOOST_CHECK_EQUAL(lexical_cast<float>(rng), 1.0f);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<double>(rng), 1.0);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<long double>(rng), 1.0L);
|
||||
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::long_long_type>(rng), 1);
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng), 1u);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng), 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);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<long double>(rng1), 1.0L);
|
||||
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);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<long double>(crng2), 1.0L);
|
||||
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_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && 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_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && 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_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
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;
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
// 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()
|
||||
{
|
||||
test_round_conversion<long double>();
|
||||
test_msvc_magic_values<long double>();
|
||||
}
|
||||
|
||||
@@ -1,95 +0,0 @@
|
||||
// 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;
|
||||
}
|
||||
|
||||
@@ -1,166 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2012.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
// Testing compilation and some basic usage with BOOST_NO_STD_LOCALE
|
||||
// Tests are mainly copyied from lexical_cast_empty_input_test.cpp (something
|
||||
// new added to test_empty_3)
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
#error "This test must be compiled with -DBOOST_NO_STD_LOCALE"
|
||||
#endif
|
||||
|
||||
|
||||
template <class T>
|
||||
void do_test_on_empty_input(T& v)
|
||||
{
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_empty_1()
|
||||
{
|
||||
boost::iterator_range<char*> v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
|
||||
boost::iterator_range<const char*> cv;
|
||||
do_test_on_empty_input(cv);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
|
||||
|
||||
const boost::iterator_range<const char*> ccv;
|
||||
do_test_on_empty_input(ccv);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_empty_2()
|
||||
{
|
||||
std::string v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
}
|
||||
|
||||
struct Escape
|
||||
{
|
||||
Escape(){}
|
||||
Escape(const std::string& s)
|
||||
: str_(s)
|
||||
{}
|
||||
|
||||
std::string str_;
|
||||
};
|
||||
|
||||
inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
|
||||
{
|
||||
return o << rhs.str_;
|
||||
}
|
||||
|
||||
inline std::istream& operator>> (std::istream& i, Escape& rhs)
|
||||
{
|
||||
return i >> rhs.str_;
|
||||
}
|
||||
|
||||
void test_empty_3()
|
||||
{
|
||||
Escape v("");
|
||||
do_test_on_empty_input(v);
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
|
||||
v = lexical_cast<Escape>(100);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<int>(v), 100);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(v), 100u);
|
||||
|
||||
v = lexical_cast<Escape>(0.0);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<double>(v), 0.0);
|
||||
}
|
||||
|
||||
namespace std {
|
||||
inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
|
||||
{
|
||||
std::ostream_iterator<long> it(out);
|
||||
std::copy(v.begin(), v.end(), it);
|
||||
assert(out);
|
||||
return out;
|
||||
}
|
||||
}
|
||||
|
||||
void test_empty_4()
|
||||
{
|
||||
std::vector<long> v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
}
|
||||
|
||||
|
||||
struct my_string {
|
||||
friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
|
||||
return sout << "";
|
||||
}
|
||||
};
|
||||
|
||||
void test_empty_5()
|
||||
{
|
||||
my_string st;
|
||||
BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
|
||||
}
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast. Testing with BOOST_NO_STD_LOCALE");
|
||||
suite->add(BOOST_TEST_CASE(&test_empty_1));
|
||||
suite->add(BOOST_TEST_CASE(&test_empty_2));
|
||||
suite->add(BOOST_TEST_CASE(&test_empty_3));
|
||||
suite->add(BOOST_TEST_CASE(&test_empty_4));
|
||||
suite->add(BOOST_TEST_CASE(&test_empty_5));
|
||||
|
||||
return suite;
|
||||
}
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
// 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");
|
||||
}
|
||||
|
||||
@@ -1,96 +0,0 @@
|
||||
// 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;
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
// 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;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,48 +0,0 @@
|
||||
// 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;
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
// 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] += 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] += 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;
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
// 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");
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(true);
|
||||
}
|
||||
|
||||
void test_char_types_conversions_char16_t()
|
||||
{
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
test_impl(u"Test array of chars");
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(true);
|
||||
}
|
||||
|
||||
void test_char_types_conversions_char32_t()
|
||||
{
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
test_impl(U"Test array of chars");
|
||||
#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;
|
||||
}
|
||||
Reference in New Issue
Block a user