feedc0de/boost_system
1
0
Fork 0
forked from boostorg/system
Code Pull Requests Activity

Upgrade system and filesystem to conform system_category and generic_category interface to N3090, the current C++0x working paper, section 19.5, System error support.

Browse Source 
Refactor API macros into a new header, boost/system/api_config.hpp.

Prohibit user definition of API macros. Rationale: ensure all translation units use same definitions, cut number of environments that need to be tested.

[SVN r62313]
This commit is contained in:
Beman Dawes
2010-05-30 15:38:32 +00:00
parent 2565e5307b
commit baae3a392a
15 changed files with 248 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
doc/index.html
View File

@ -93,6 +93,18 @@ supports both error reporting by exception and by error code.</p>
error_code.hpp</code> header, system-specific headers support the Cygwin, Linux,
and Windows platforms. These headers are effectively no-ops if included for
platforms other than their intended target.</p>
<table border="1" cellpadding="10" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
<tr>
<td>The Boost System Library will become part of the C++0x Standard Library.
A number of changes, particularly to names, were made by the C++ committee
during standardization. The Boost implementation is tracking those changes.
See <a href="reference.html#Deprecated-names">Deprecated names</a> for
synonyms provided to prevent breakage of existing user code. See
<a href="reference.html#Breaking-changes">Breaking changes</a> for changes
that unavoidably break existing user code. All breaking changes are noisy
and will cause compile-time errors.</td>
</tr>
</table>
<h2><a name="Design_Rationale">Design Rationale</a></h2>
<p>Class <code>error_code</code>&nbsp; and <code>error_condition</code> are designed as a value types so
they can be copied
@ -133,7 +145,7 @@ paper. Johan Nilsson's comments led to several of the refinements in N2066 .</p>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->February 23, 2008<!--webbot bot="Timestamp" endspan i-checksum="41408" --> </font>
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->May 28, 2010<!--webbot bot="Timestamp" endspan i-checksum="11241" --> </font>
</p>
<p><EFBFBD> Copyright Beman Dawes, 1999</p>

104
doc/reference.html
View File

@ -40,6 +40,7 @@
<a href="#Introduction">Introduction</a><br>
<a href="#Macros">Macros</a><br>
<a href="#Deprecated-names">Deprecated names</a><br>
<a href="#Breaking-changes">Breaking changes</a><br>
<a href="#Header-error_code">Header &lt;boost/system/error_code.hpp&gt;</a><br>
<a href="#Class-error_category">Class <code>error_category</code></a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_category-synopsis">Class <code>error_category</code> synopsis</a><br>
@ -77,55 +78,50 @@ errno</code>.</p>
<h2><a name="Macros">Macros</a></h2>
<p>Users may defined the following macros if desired. Sensible defaults are
provided, so users may ignore these macros if they prefer.</p>
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" height="368">
<tr>
<td><b><i>Macro Name</i></b></td>
<td><b><i>Default</i></b></td>
<td><b><i>Effect if defined</i></b></td>
<td height="16"><b><i>Macro Name</i></b></td>
<td height="16"><b><i>Default</i></b></td>
<td height="16"><b><i>Effect if defined</i></b></td>
</tr>
<tr>
<td valign="top"><code>BOOST_WINDOWS_API</code></td>
<td valign="top">Defined if Windows is detected by Boost.System's automatic configuration
code, otherwise not defined.</td>
<td valign="top">Implementation uses the Microsoft Windows native
application program interface (API).</td>
</tr>
<tr>
<td valign="top"><code>BOOST_POSIX_API</code></td>
<td valign="top">Defined if Windows is not detected by Boost.System's automatic configuration
code.</td>
<td valign="top">Implementation uses the POSIX native
application program interface (API).</td>
</tr>
<tr>
<td valign="top"><code>BOOST_SYSTEM_DYN_LINK</code></td>
<td valign="top">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined,
<td valign="top" height="64"><code>BOOST_SYSTEM_DYN_LINK</code></td>
<td valign="top" height="64">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined,
otherwise not defined.</td>
<td valign="top">Boost.System library is dynamically linked. If not defined,
<td valign="top" height="64">Boost.System library is dynamically linked. If not defined,
static linking is assumed.</td>
</tr>
<tr>
<td valign="top"><code>BOOST_SYSTEM_NO_LIB</code></td>
<td valign="top">Defined if <code>BOOST_ALL_NO_LIB</code> is defined,
<td valign="top" height="47"><code>BOOST_SYSTEM_NO_LIB</code></td>
<td valign="top" height="47">Defined if <code>BOOST_ALL_NO_LIB</code> is defined,
otherwise not defined.</td>
<td valign="top">Boost.System library does not use the Boost auto-link
<td valign="top" height="47">Boost.System library does not use the Boost auto-link
facility.</td>
</tr>
<tr>
<td valign="top"><code>BOOST_SYSTEM_NO_DEPRECATED</code></td>
<td valign="top">Not defined.</td>
<td valign="top">Deprecated features are excluded.</td>
<td valign="top" height="32"><code>BOOST_SYSTEM_NO_DEPRECATED</code></td>
<td valign="top" height="32">Not defined.</td>
<td valign="top" height="32">Deprecated features are excluded.</td>
</tr>
</table>
</table>
<h2><a name="Deprecated-names">Deprecated names</a></h2>
<p>In the process of adding Boost.System to C++0x standard library, some of the
names are being changed. To ease transition, Boost.System deprecates the old
<p>In the process of adding Boost.System to C++0x standard library, the C++
committee changed some
names. To ease transition, Boost.System deprecates the old
names, but continues to provide them unless macro <code>BOOST_SYSTEM_NO_DEPRECATED</code>
is defined.</p>
<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
<tr>
<td><b><i>Old name, now deprecated</i></b></td>
<td><b><i>New name</i></b></td>
<td><b><i>Old usage, now deprecated</i></b></td>
<td><b><i>Replacement</i></b></td>
</tr>
<tr>
<td><code>get_generic_category()</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>get_system_category()</code></td>
<td><code>system_category()</code></td>
</tr>
<tr>
<td><code>namespace posix</code></td>
@ -141,21 +137,39 @@ is defined.</p>
</tr>
<tr>
<td><code>get_posix_category()</code></td>
<td><code>get_generic_category()</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>posix_category</code></td>
<td><code>generic_category</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>errno_ecat</code></td>
<td><code>generic_category</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>native_ecat</code></td>
<td><code>system_category</code></td>
<td><code>system_category()</code></td>
</tr>
</table>
<h2><a name="Breaking-changes">Breaking changes</a></h2>
<p>Two static consts are replaced by functions. These are breaking changes best
fixed by globally adding () to these names to turn them into function calls.</p>
<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
<tr>
<td><b><i>Old usage, now broken</i></b></td>
<td><b><i>Replacement</i></b></td>
</tr>
<tr>
<td><code>generic_category</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>system_category</code></td>
<td><code>system_category()</code></td>
</tr>
</table>
<p>User-defined BOOST_POSIX_API and BOOST_WINDOWS_API are no longer supported.</p>
<h2><a name="Header-error_code">Header &lt;boost/system/error_code.hpp&gt;</a></h2>
<h3>&lt;boost/system/error_code.hpp&gt; synopsis</h3>
<blockquote>
@ -265,9 +279,6 @@ is defined.</p>
template<> struct is_error_condition_enum<posix::posix_errno>&lt;errc::errc_t&gt;
{ static const bool value = true; };
// predefined error_code object used as &quot;throw on error&quot; tag
extern error_code <a href="#throws-object">throws</a>;
// <a href="#Non-member-functions">non-member functions</a>
bool operator==( const error_code &amp; lhs, const error_code &amp; rhs );
@ -336,11 +347,8 @@ types should create a single object of each such type. <i>
bool operator&lt; ( const error_category &amp; rhs ) const;
};
const error_category &amp; get_system_category();
const error_category &amp; get_generic_category();
static const error_category &amp; system_category = get_system_category();
static const error_category &amp; generic_category = get_generic_category();
const error_category &amp; system_category();
const error_category &amp; generic_category();
}
}</pre>
</blockquote>
@ -402,13 +410,13 @@ const;</code></p>
</blockquote>
<h3><a name="Class-error_category-non-member-functions">Class <code>error_category</code>
non-member functions</a></h3>
<pre>const error_category &amp; get_system_category();</pre>
<pre>const error_category &amp; system_category();</pre>
<blockquote>
<p><i>Returns:</i> A reference to a <code>error_category</code> object
identifying errors originating from the operating system.</p>
<p><i>Throws:</i> Nothing.</p>
</blockquote>
<pre>const error_category &amp; get_generic_category();</pre>
<pre>const error_category &amp; generic_category();</pre>
<blockquote>
<p><i>Returns:</i> A reference to a <code>error_category</code> object
identifying portable error conditions.</p>
@ -831,7 +839,7 @@ application program interfaces.</p>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->October 11, 2008<!--webbot bot="Timestamp" endspan i-checksum="30976" --> </font>
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->May 29, 2010<!--webbot bot="Timestamp" endspan i-checksum="11273" --> </font>
</p>
<p><EFBFBD> Copyright Beman Dawes, 2006, 2007, 2008</p>
@ -841,4 +849,4 @@ application program interfaces.</p>
</body>
</html>
</html>

42
include/boost/system/api_config.hpp Normal file
View File

@ -0,0 +1,42 @@
// boost/system/api_config.hpp -------------------------------------------------------//
// Copyright Beman Dawes 2003, 2006, 2010
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/system for documentation.
//--------------------------------------------------------------------------------------//
// Boost.System calls operating system API functions to implement system error category
// functions. Usually there is no question as to which API is to be used.
//
// In the case of MinGW or Cygwin/MinGW, however, both POSIX and Windows API's are
// available. Chaos ensues if other code thinks one is in use when Boost.System was
// actually built with the other. This header centralizes the API choice and prevents
// user definition of API macros, thus elminating the possibility of mismatches and the
// need to test configurations with little or no practical value.
//
//--------------------------------------------------------------------------------------//
#ifndef BOOST_SYSTEM_API_CONFIG_HPP
#define BOOST_SYSTEM_API_CONFIG_HPP
# if defined(BOOST_POSIX_API) || defined(BOOST_WINDOWS_API)
# error user defined BOOST_POSIX_API or BOOST_WINDOWS_API not supported
# endif
// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use
// Cygwin/MinGW does not predefine _WIN32.
// Standalone MinGW and all other known Windows compilers do predefine _WIN32
// Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too.
# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
# define BOOST_WINDOWS_API
# else
# define BOOST_POSIX_API
# endif
#endif // BOOST_SYSTEM_API_CONFIG_HPP

18
include/boost/system/config.hpp
View File

@ -11,22 +11,10 @@
#define BOOST_SYSTEM_CONFIG_HPP
#include <boost/config.hpp>
#include <boost/system/api_config.hpp> // for BOOST_POSIX_API or BOOST_WINDOWS_API
// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use.
// If not specified, a sensible default will be applied.
# if defined( BOOST_WINDOWS_API ) && defined( BOOST_POSIX_API )
# error both BOOST_WINDOWS_API and BOOST_POSIX_API are defined
# elif !defined( BOOST_WINDOWS_API ) && !defined( BOOST_POSIX_API )
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
// All Win32 development environments, including 64-bit Windows and MinGW, define
// _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment,
// so does not define _WIN32 or its variants.
# define BOOST_WINDOWS_API
# else
# define BOOST_POSIX_API
# endif
# endif
// This header implements separate compilation features as described in
// http://www.boost.org/more/separate_compilation.html
// enable dynamic or static linking as requested --------------------------------------//

4
include/boost/system/cygwin_error.hpp
View File

@ -23,7 +23,7 @@ namespace boost
{
// To construct an error_code after a API error:
//
// error_code( errno, system_category )
// error_code( errno, system_category() )
// User code should use the portable "posix" enums for POSIX errors; this
// allows such code to be portable to non-POSIX systems. For the non-POSIX
@ -46,7 +46,7 @@ namespace boost
namespace cygwin_error
{
inline error_code make_error_code( cygwin_errno e )
{ return error_code( e, get_system_category() ); }
{ return error_code( e, system_category() ); }
}
}
}

32
include/boost/system/error_code.hpp
View File

@ -202,18 +202,18 @@ namespace boost
// predefined error categories -----------------------------------------//
BOOST_SYSTEM_DECL const error_category & get_system_category();
BOOST_SYSTEM_DECL const error_category & get_generic_category();
BOOST_SYSTEM_DECL const error_category & system_category();
BOOST_SYSTEM_DECL const error_category & generic_category();
// deprecated synonyms --------------------------------------------------//
static const error_category & system_category = get_system_category();
static const error_category & generic_category = get_generic_category();
# ifndef BOOST_SYSTEM_NO_DEPRECATED
// deprecated synonyms
inline const error_category & get_posix_category() { return get_generic_category(); }
static const error_category & posix_category = get_generic_category();
static const error_category & errno_ecat = get_generic_category();
static const error_category & native_ecat = get_system_category();
inline const error_category & get_system_category() { return system_category(); }
inline const error_category & get_generic_category() { return generic_category(); }
inline const error_category & get_posix_category() { return generic_category(); }
static const error_category & posix_category = generic_category();
static const error_category & errno_ecat = generic_category();
static const error_category & native_ecat = system_category();
# endif
// class error_condition -----------------------------------------------//
@ -225,7 +225,7 @@ namespace boost
public:
// constructors:
error_condition() : m_val(0), m_cat(&get_generic_category()) {}
error_condition() : m_val(0), m_cat(&generic_category()) {}
error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
template <class ErrorConditionEnum>
@ -254,7 +254,7 @@ namespace boost
void clear()
{
m_val = 0;
m_cat = &get_generic_category();
m_cat = &generic_category();
}
// observers:
@ -312,7 +312,7 @@ namespace boost
public:
// constructors:
error_code() : m_val(0), m_cat(&get_system_category()) {}
error_code() : m_val(0), m_cat(&system_category()) {}
error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
template <class ErrorCodeEnum>
@ -340,7 +340,7 @@ namespace boost
void clear()
{
m_val = 0;
m_cat = &get_system_category();
m_cat = &system_category();
}
// observers:
@ -473,11 +473,11 @@ namespace boost
{
// explicit conversion:
inline error_code make_error_code( errc_t e )
{ return error_code( e, get_generic_category() ); }
{ return error_code( e, generic_category() ); }
// implicit conversion:
inline error_condition make_error_condition( errc_t e )
{ return error_condition( e, get_generic_category() ); }
{ return error_condition( e, generic_category() ); }
}
// error_category default implementation -------------------------------//

4
include/boost/system/linux_error.hpp
View File

@ -23,7 +23,7 @@ namespace boost
{
// To construct an error_code after a API error:
//
// error_code( errno, system_category )
// error_code( errno, system_category() )
// User code should use the portable "posix" enums for POSIX errors; this
// allows such code to be portable to non-POSIX systems. For the non-POSIX
@ -99,7 +99,7 @@ namespace boost
namespace linux_error
{
inline error_code make_error_code( linux_errno e )
{ return error_code( e, get_system_category() ); }
{ return error_code( e, system_category() ); }
}
} // namespace system

4
include/boost/system/windows_error.hpp
View File

@ -29,7 +29,7 @@ namespace boost
// To construct an error_code after a API error:
//
// error_code( ::GetLastError(), system_category )
// error_code( ::GetLastError(), system_category() )
namespace windows_error
{
@ -107,7 +107,7 @@ namespace boost
namespace windows_error
{
inline error_code make_error_code( windows_error_code e )
{ return error_code( e, get_system_category() ); }
{ return error_code( e, system_category() ); }
}
} // namespace system

10
src/error_code.cpp
View File

@ -159,7 +159,7 @@ namespace
switch ( ev )
{
case 0: return make_error_condition( success );
# if defined(BOOST_POSIX_API)
# if defined(BOOST_POSIX_API)
// POSIX-like O/S -> posix_errno decode table ---------------------------//
case E2BIG: return make_error_condition( argument_list_too_long );
case EACCES: return make_error_condition( permission_denied );
@ -329,7 +329,7 @@ namespace
case WSAETIMEDOUT: return make_error_condition( timed_out );
case WSAEWOULDBLOCK: return make_error_condition( operation_would_block );
#endif
default: return error_condition( ev, system_category );
default: return error_condition( ev, system_category() );
}
}
@ -337,7 +337,7 @@ namespace
std::string system_error_category::message( int ev ) const
{
return generic_category.message( ev );
return generic_category().message( ev );
}
# else
// TODO:
@ -423,13 +423,13 @@ namespace boost
// address for comparison purposes
# endif
BOOST_SYSTEM_DECL const error_category & get_system_category()
BOOST_SYSTEM_DECL const error_category & system_category()
{
static const system_error_category system_category_const;
return system_category_const;
}
BOOST_SYSTEM_DECL const error_category & get_generic_category()
BOOST_SYSTEM_DECL const error_category & generic_category()
{
static const generic_error_category generic_category_const;
return generic_category_const;

108
test/error_code_test.cpp
View File

@ -68,20 +68,20 @@ int main( int, char ** )
std::cout << "General tests...\n";
// unit tests:
BOOST_TEST( generic_category == generic_category );
BOOST_TEST( system_category == system_category );
BOOST_TEST( generic_category != system_category );
BOOST_TEST( system_category != generic_category );
BOOST_TEST( generic_category() == generic_category() );
BOOST_TEST( system_category() == system_category() );
BOOST_TEST( generic_category() != system_category() );
BOOST_TEST( system_category() != generic_category() );
if ( std::less<const error_category*>()( &generic_category, &system_category ) )
if ( std::less<const error_category*>()( &generic_category(), &system_category() ) )
{
BOOST_TEST( generic_category < system_category );
BOOST_TEST( !(system_category < generic_category) );
BOOST_TEST( generic_category() < system_category() );
BOOST_TEST( !(system_category() < generic_category()) );
}
else
{
BOOST_TEST( system_category < generic_category );
BOOST_TEST( !(generic_category < system_category) );
BOOST_TEST( system_category() < generic_category() );
BOOST_TEST( !(generic_category() < system_category()) );
}
@ -91,29 +91,29 @@ int main( int, char ** )
BOOST_TEST( ec.value() == 0 );
econd = ec.default_error_condition();
BOOST_TEST( econd.value() == 0 );
BOOST_TEST( econd.category() == generic_category );
BOOST_TEST( econd.category() == generic_category() );
BOOST_TEST( ec == errc::success );
BOOST_TEST( ec.category() == system_category );
BOOST_TEST( ec.category() == system_category() );
BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
BOOST_TEST( !(ec < error_code( 0, system_category )) );
BOOST_TEST( !(error_code( 0, system_category ) < ec) );
BOOST_TEST( ec < error_code( 1, system_category ) );
BOOST_TEST( !(error_code( 1, system_category ) < ec) );
BOOST_TEST( !(ec < error_code( 0, system_category() )) );
BOOST_TEST( !(error_code( 0, system_category() ) < ec) );
BOOST_TEST( ec < error_code( 1, system_category() ) );
BOOST_TEST( !(error_code( 1, system_category() ) < ec) );
error_code ec_0_system( 0, system_category );
error_code ec_0_system( 0, system_category() );
BOOST_TEST( !ec_0_system );
BOOST_TEST( ec_0_system.value() == 0 );
econd = ec_0_system.default_error_condition();
BOOST_TEST( econd.value() == 0 );
BOOST_TEST( econd.category() == generic_category );
BOOST_TEST( econd.category() == generic_category() );
BOOST_TEST( ec_0_system == errc::success );
BOOST_TEST( ec_0_system.category() == system_category );
BOOST_TEST( ec_0_system.category() == system_category() );
BOOST_TEST( std::strcmp( ec_0_system.category().name(), "system") == 0 );
check_ostream( ec_0_system, "system:0" );
BOOST_TEST( ec_0_system == ec );
error_code ec_1_system( 1, system_category );
error_code ec_1_system( 1, system_category() );
BOOST_TEST( ec_1_system );
BOOST_TEST( ec_1_system.value() == 1 );
BOOST_TEST( ec_1_system.value() != 0 );
@ -121,17 +121,17 @@ int main( int, char ** )
BOOST_TEST( ec_0_system != ec_1_system );
check_ostream( ec_1_system, "system:1" );
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
BOOST_TEST( ec );
BOOST_TEST( ec.value() == BOOST_ACCESS_ERROR_MACRO );
econd = ec.default_error_condition();
BOOST_TEST( econd.value() == static_cast<int>(errc::permission_denied) );
BOOST_TEST( econd.category() == generic_category );
BOOST_TEST( econd == error_condition( errc::permission_denied, generic_category ) );
BOOST_TEST( econd.category() == generic_category() );
BOOST_TEST( econd == error_condition( errc::permission_denied, generic_category() ) );
BOOST_TEST( econd == errc::permission_denied );
BOOST_TEST( errc::permission_denied == econd );
BOOST_TEST( ec == errc::permission_denied );
BOOST_TEST( ec.category() == system_category );
BOOST_TEST( ec.category() == system_category() );
BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
// test the explicit make_error_code conversion for errc
@ -141,17 +141,17 @@ int main( int, char ** )
BOOST_TEST( errc::bad_message == ec );
BOOST_TEST( ec != errc::permission_denied );
BOOST_TEST( errc::permission_denied != ec );
BOOST_TEST( ec.category() == generic_category );
BOOST_TEST( ec.category() == generic_category() );
//// test the deprecated predefined error_category synonyms
//BOOST_TEST( &system_category == &native_ecat );
//BOOST_TEST( &generic_category == &errno_ecat );
//BOOST_TEST( system_category == native_ecat );
//BOOST_TEST( generic_category == errno_ecat );
//BOOST_TEST( &system_category() == &native_ecat );
//BOOST_TEST( &generic_category() == &errno_ecat );
//BOOST_TEST( system_category() == native_ecat );
//BOOST_TEST( generic_category() == errno_ecat );
// test error_code and error_condition message();
// see Boost.Filesystem operations_test for code specific message() tests
ec = error_code( -1, system_category );
ec = error_code( -1, system_category() );
std::cout << "error_code message for -1 is \"" << ec.message() << "\"\n";
std::cout << "error_code message for 0 is \"" << ec_0_system.message() << "\"\n";
#if defined(BOOST_WINDOWS_API)
@ -169,11 +169,11 @@ int main( int, char ** )
BOOST_TEST( ec.message() == "error -1" );
#endif
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
BOOST_TEST( ec.message() != "" );
BOOST_TEST( ec.message().substr( 0, 13) != "Unknown error" );
econd = error_condition( -1, generic_category );
econd = error_condition( -1, generic_category() );
error_condition econd_ok;
std::cout << "error_condition message for -1 is \"" << econd.message() << "\"\n";
std::cout << "error_condition message for 0 is \"" << econd_ok.message() << "\"\n";
@ -192,7 +192,7 @@ int main( int, char ** )
BOOST_TEST( econd.message() == "error -1" );
#endif
econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category );
econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category() );
BOOST_TEST( econd.message() != "" );
BOOST_TEST( econd.message().substr( 0, 13) != "Unknown error" );
@ -200,74 +200,74 @@ int main( int, char ** )
std::cout << "Windows tests...\n";
// these tests probe the Windows errc decoder
// test the first entry in the decoder table:
ec = error_code( ERROR_ACCESS_DENIED, system_category );
ec = error_code( ERROR_ACCESS_DENIED, system_category() );
BOOST_TEST( ec.value() == ERROR_ACCESS_DENIED );
BOOST_TEST( ec == errc::permission_denied );
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
BOOST_TEST( ec.default_error_condition().category() == generic_category );
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
// test the second entry in the decoder table:
ec = error_code( ERROR_ALREADY_EXISTS, system_category );
ec = error_code( ERROR_ALREADY_EXISTS, system_category() );
BOOST_TEST( ec.value() == ERROR_ALREADY_EXISTS );
BOOST_TEST( ec == errc::file_exists );
BOOST_TEST( ec.default_error_condition().value() == errc::file_exists );
BOOST_TEST( ec.default_error_condition().category() == generic_category );
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
// test the third entry in the decoder table:
ec = error_code( ERROR_BAD_UNIT, system_category );
ec = error_code( ERROR_BAD_UNIT, system_category() );
BOOST_TEST( ec.value() == ERROR_BAD_UNIT );
BOOST_TEST( ec == errc::no_such_device );
BOOST_TEST( ec.default_error_condition().value() == errc::no_such_device );
BOOST_TEST( ec.default_error_condition().category() == generic_category );
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
// test the last non-Winsock entry in the decoder table:
ec = error_code( ERROR_WRITE_PROTECT, system_category );
ec = error_code( ERROR_WRITE_PROTECT, system_category() );
BOOST_TEST( ec.value() == ERROR_WRITE_PROTECT );
BOOST_TEST( ec == errc::permission_denied );
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
BOOST_TEST( ec.default_error_condition().category() == generic_category );
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
// test the last Winsock entry in the decoder table:
ec = error_code( WSAEWOULDBLOCK, system_category );
ec = error_code( WSAEWOULDBLOCK, system_category() );
BOOST_TEST( ec.value() == WSAEWOULDBLOCK );
BOOST_TEST( ec == errc::operation_would_block );
BOOST_TEST( ec.default_error_condition().value() == errc::operation_would_block );
BOOST_TEST( ec.default_error_condition().category() == generic_category );
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
// test not-in-table condition:
ec = error_code( 1234567890, system_category );
ec = error_code( 1234567890, system_category() );
BOOST_TEST( ec.value() == 1234567890 );
BOOST_TEST( ec.default_error_condition().value() == 1234567890 );
BOOST_TEST( ec.default_error_condition().category() == system_category );
BOOST_TEST( ec.default_error_condition().category() == system_category() );
#else // POSIX
std::cout << "POSIX tests...\n";
ec = error_code( EACCES, system_category );
BOOST_TEST( ec == error_code( errc::permission_denied, system_category ) );
BOOST_TEST( error_code( errc::permission_denied, system_category ) == ec );
ec = error_code( EACCES, system_category() );
BOOST_TEST( ec == error_code( errc::permission_denied, system_category() ) );
BOOST_TEST( error_code( errc::permission_denied, system_category() ) == ec );
BOOST_TEST( ec == errc::permission_denied );
BOOST_TEST( errc::permission_denied == ec );
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
BOOST_TEST( ec.default_error_condition().category() == generic_category );
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
# ifdef __CYGWIN__
std::cout << "Cygwin tests...\n";
ec = cygwin_error::no_package;
BOOST_TEST( ec == cygwin_error::no_package );
BOOST_TEST( ec == error_code( ENOPKG, system_category ) );
BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category ) );
BOOST_TEST( ec.default_error_condition().category() == system_category );
BOOST_TEST( ec == error_code( ENOPKG, system_category() ) );
BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category() ) );
BOOST_TEST( ec.default_error_condition().category() == system_category() );
# elif defined(linux) || defined(__linux) || defined(__linux__)
std::cout << "Linux tests...\n";
ec = linux_error::dot_dot_error;
BOOST_TEST( ec == linux_error::dot_dot_error );
BOOST_TEST( ec == error_code( EDOTDOT, system_category ) );
BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category ) );
BOOST_TEST( ec.default_error_condition().category() == system_category );
BOOST_TEST( ec == error_code( EDOTDOT, system_category() ) );
BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category() ) );
BOOST_TEST( ec.default_error_condition().category() == system_category() );
# endif

68
test/error_code_user_test.cpp
View File

@ -14,6 +14,8 @@
// Motivation was a Boost posting by Christopher Kohlhoff on June 28, 2006.
#define BOOST_SYSTEM_NO_DEPRECATED
#include <boost/system/error_code.hpp>
#include <boost/cerrno.hpp>
#include <string>
@ -40,7 +42,7 @@ boost::system::error_code my_mkdir( const std::string & path )
# else
::CreateDirectoryA( path.c_str(), 0 ) != 0 ? 0 : ::GetLastError(),
# endif
boost::system::system_category );
boost::system::system_category() );
}
// ------------------------------------------------------------------------ //
@ -53,9 +55,9 @@ boost::system::error_code my_remove( const std::string & path )
{
return boost::system::error_code(
std::remove( path.c_str() ) == 0 ? 0 : errno,
boost::system::posix_category ); // OK for both Windows and POSIX
// Alternatively, could use posix_category
// on Windows and system_category on
boost::system::generic_category() ); // OK for both Windows and POSIX
// Alternatively, could use generic_category()
// on Windows and system_category() on
// POSIX-based systems.
}
@ -118,8 +120,8 @@ namespace boost
boost::system::error_condition default_error_condition( int ev ) const
{
return ev == boo_boo
? boost::system::error_condition( boost::system::posix::io_error,
boost::system::posix_category )
? boost::system::error_condition( boost::system::errc::io_error,
boost::system::generic_category() )
: boost::system::error_condition( ev,
boost::lib3::lib3_error_category );
}
@ -180,8 +182,8 @@ namespace lib4
boost::system::error_condition default_error_condition( int ev ) const
{
return ev == boo_boo.value()
? boost::system::error_condition( boost::system::posix::io_error,
boost::system::posix_category )
? boost::system::error_condition( boost::system::errc::io_error,
boost::system::generic_category() )
: boost::system::error_condition( ev, lib4::lib4_error_category );
}
@ -237,15 +239,15 @@ namespace lib4
// switch (ev)
// {
// case user_success:
// return boost::system::error_code(boost::system::posix::success, boost::system::posix_category);
// return boost::system::error_code(boost::system::errc::success, boost::system::generic_category());
// case user_permission_denied:
// return boost::system::error_code(boost::system::posix::permission_denied, boost::system::posix_category);
// return boost::system::error_code(boost::system::errc::permission_denied, boost::system::generic_category());
// case user_out_of_memory:
// return boost::system::error_code(boost::system::posix::not_enough_memory, boost::system::posix_category);
// return boost::system::error_code(boost::system::errc::not_enough_memory, boost::system::generic_category());
// default:
// break;
// }
// return boost::system::error_code(boost::system::posix::no_posix_equivalent, boost::system::posix_category);
// return boost::system::error_code(boost::system::errc::no_posix_equivalent, boost::system::generic_category());
// }
//
// };
@ -264,8 +266,8 @@ namespace lib4
//
// void check_success(const boost::system::error_code& ec, bool expect)
// {
// BOOST_TEST( (ec == boost::system::posix::success) == expect );
// if (ec == boost::system::posix::success)
// BOOST_TEST( (ec == boost::system::errc::success) == expect );
// if (ec == boost::system::errc::success)
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
// else
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
@ -273,8 +275,8 @@ namespace lib4
//
// void check_permission_denied(const boost::system::error_code& ec, bool expect)
// {
// BOOST_TEST( (ec == boost::system::posix::permission_denied) == expect );
// if (ec == boost::system::posix::permission_denied)
// BOOST_TEST( (ec == boost::system::errc::permission_denied) == expect );
// if (ec == boost::system::errc::permission_denied)
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
// else
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
@ -282,8 +284,8 @@ namespace lib4
//
// void check_out_of_memory(const boost::system::error_code& ec, bool expect)
// {
// BOOST_TEST( (ec == boost::system::posix::not_enough_memory) == expect );
// if (ec == boost::system::posix::not_enough_memory)
// BOOST_TEST( (ec == boost::system::errc::not_enough_memory) == expect );
// if (ec == boost::system::errc::not_enough_memory)
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
// else
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
@ -295,23 +297,23 @@ namespace lib4
// printf("=====\n");
// boost::system::error_code ec;
// check_success(ec, true);
// check_success(boost::system::posix::success, true);
// check_success(boost::system::posix::permission_denied, false);
// check_success(boost::system::posix::not_enough_memory, false);
// check_success(boost::system::errc::success, true);
// check_success(boost::system::errc::permission_denied, false);
// check_success(boost::system::errc::not_enough_memory, false);
// check_success(user_success, true);
// check_success(user_permission_denied, false);
// check_success(user_out_of_memory, false);
// check_permission_denied(ec, false);
// check_permission_denied(boost::system::posix::success, false);
// check_permission_denied(boost::system::posix::permission_denied, true);
// check_permission_denied(boost::system::posix::not_enough_memory, false);
// check_permission_denied(boost::system::errc::success, false);
// check_permission_denied(boost::system::errc::permission_denied, true);
// check_permission_denied(boost::system::errc::not_enough_memory, false);
// check_permission_denied(user_success, false);
// check_permission_denied(user_permission_denied, true);
// check_permission_denied(user_out_of_memory, false);
// check_out_of_memory(ec, false);
// check_out_of_memory(boost::system::posix::success, false);
// check_out_of_memory(boost::system::posix::permission_denied, false);
// check_out_of_memory(boost::system::posix::not_enough_memory, true);
// check_out_of_memory(boost::system::errc::success, false);
// check_out_of_memory(boost::system::errc::permission_denied, false);
// check_out_of_memory(boost::system::errc::not_enough_memory, true);
// check_out_of_memory(user_success, false);
// check_out_of_memory(user_permission_denied, false);
// check_out_of_memory(user_out_of_memory, true);
@ -347,8 +349,8 @@ int main( int, char *[] )
std::cout << "ec.value() is " << ec.value() << '\n';
BOOST_TEST( ec );
BOOST_TEST( ec == boost::system::posix::no_such_file_or_directory );
BOOST_TEST( ec.category() == boost::system::system_category );
BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
BOOST_TEST( ec.category() == boost::system::system_category() );
// Library 2 tests:
@ -356,8 +358,8 @@ int main( int, char *[] )
std::cout << "ec.value() is " << ec.value() << '\n';
BOOST_TEST( ec );
BOOST_TEST( ec == boost::system::posix::no_such_file_or_directory );
BOOST_TEST( ec.category() == boost::system::posix_category );
BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
BOOST_TEST( ec.category() == boost::system::generic_category() );
// Library 3 tests:
@ -369,7 +371,7 @@ int main( int, char *[] )
BOOST_TEST( ec.value() == boost::lib3::boo_boo );
BOOST_TEST( ec.category() == boost::lib3::lib3_error_category );
BOOST_TEST( ec == boost::system::posix::io_error );
BOOST_TEST( ec == boost::system::errc::io_error );
boost::system::error_code ec3( boost::lib3::boo_boo+100,
boost::lib3::lib3_error_category );
@ -387,7 +389,7 @@ int main( int, char *[] )
BOOST_TEST( ec.value() == lib4::boo_boo.value() );
BOOST_TEST( ec.category() == lib4::lib4_error_category );
BOOST_TEST( ec == boost::system::posix::io_error );
BOOST_TEST( ec == boost::system::errc::io_error );
boost::system::error_code ec4( lib4::boo_boo.value()+100,
lib4::lib4_error_category );

2
test/header_only_test.cpp
View File

@ -18,6 +18,6 @@
int main( int, char*[] )
{
boost::system::error_code ec( 0, boost::system::system_category );
boost::system::error_code ec( 0, boost::system::system_category() );
return ::boost::report_errors();
}

2
test/initialization_test.cpp
View File

@ -24,5 +24,5 @@ struct foo
int main( int, char ** )
{
return 0;
return ::boost::report_errors();
}

30
test/system_error_test.cpp
View File

@ -37,7 +37,7 @@ namespace
{
std::cout << "test " << desc << "\n what() returns \"" << ex.what() << "\"\n";
BOOST_TEST( ex.code().value() == v );
BOOST_TEST( ex.code().category() == system_category );
BOOST_TEST( ex.code().category() == system_category() );
# ifdef BOOST_WINDOWS_API
LANGID language_id;
# if !defined(__MINGW32__) && !defined(__CYGWIN__)
@ -63,25 +63,25 @@ int main( int, char *[] )
{
// all constructors, in the same order as they appear in the header:
system_error c1_0( error_code(0, system_category) );
system_error c1_1( error_code(1, system_category) );
system_error c1_2u( error_code(uvalue, system_category) );
system_error c1_0( error_code(0, system_category()) );
system_error c1_1( error_code(1, system_category()) );
system_error c1_2u( error_code(uvalue, system_category()) );
system_error c2_0( error_code(0, system_category), string("c2_0") );
system_error c2_1( error_code(1, system_category), string("c2_1") );
system_error c2_0( error_code(0, system_category()), string("c2_0") );
system_error c2_1( error_code(1, system_category()), string("c2_1") );
system_error c3_0( error_code(0, system_category), "c3_0" );
system_error c3_1( error_code(1, system_category), "c3_1" );
system_error c3_0( error_code(0, system_category()), "c3_0" );
system_error c3_1( error_code(1, system_category()), "c3_1" );
system_error c4_0( 0, system_category );
system_error c4_1( 1, system_category );
system_error c4_2u( uvalue, system_category );
system_error c4_0( 0, system_category() );
system_error c4_1( 1, system_category() );
system_error c4_2u( uvalue, system_category() );
system_error c5_0( 0, system_category, string("c5_0") );
system_error c5_1( 1, system_category, string("c5_1") );
system_error c5_0( 0, system_category(), string("c5_0") );
system_error c5_1( 1, system_category(), string("c5_1") );
system_error c6_0( 0, system_category, "c6_0" );
system_error c6_1( 1, system_category, "c6_1" );
system_error c6_0( 0, system_category(), "c6_0" );
system_error c6_1( 1, system_category(), "c6_1" );
TEST( c1_0, 0, "The operation completed successfully" );
TEST( c1_1, 1, "Incorrect function" );

2
test/throw_test.cpp
View File

@ -25,7 +25,7 @@ namespace boost
{
BOOST_SYSTEM_DECL void throw_test()
{
throw system_error(9999, get_system_category(), "boo boo");
throw system_error(9999, system_category(), "boo boo");
}
}
}