1// error_code_test.cpp -----------------------------------------------------//
2
3// Copyright Beman Dawes 2006
4
5// Distributed under the Boost Software License, Version 1.0. (See accompanying
6// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7
8// See library home page at http://www.boost.org/libs/system
9
10//----------------------------------------------------------------------------//
11
12// test without deprecated features
13#define BOOST_SYSTEM_NO_DEPRECATED
14
15#include <boost/config/warning_disable.hpp>
16
17#include <boost/detail/lightweight_test.hpp>
18#include <boost/system/error_code.hpp>
19#include <boost/system/cygwin_error.hpp>
20#include <boost/system/linux_error.hpp>
21#include <boost/system/windows_error.hpp>
22#include <iostream>
23#include <sstream>
24#include <string>
25#include <cstring>
26#include <functional>
27#include <boost/cerrno.hpp>
28
29// Although using directives are not the best programming practice, testing
30// with a boost::system using directive increases use scenario coverage.
31using namespace boost::system;
32
33# if defined( BOOST_WINDOWS_API )
34# include "winerror.h"
35# define BOOST_ACCESS_ERROR_MACRO ERROR_ACCESS_DENIED
36# elif defined( BOOST_POSIX_API )
37# define BOOST_ACCESS_ERROR_MACRO EACCES
38# else
39# error "Only supported for POSIX and Windows"
40# endif
41
42namespace
43{
44 void check_ostream( error_code ec, const char * expected )
45 {
46 std::stringstream ss;
47 std::string s;
48
49 ss << ec;
50 ss >> s;
51 BOOST_TEST( s == expected );
52 }
53}
54
55// main ------------------------------------------------------------------------------//
56
57// TODO: add hash_value tests
58
59int main( int, char ** )
60{
61
62 std::cout << "Conversion use cases...\n";
63 error_condition x1( errc::file_exists );
64 //error_code x2( errc::file_exists ); // should fail to compile
65 make_error_code(e: errc::file_exists);
66 make_error_condition(e: errc::file_exists);
67
68 std::cout << "General tests...\n";
69 // unit tests:
70
71 BOOST_TEST( generic_category() == generic_category() );
72 BOOST_TEST( system_category() == system_category() );
73 BOOST_TEST( generic_category() != system_category() );
74 BOOST_TEST( system_category() != generic_category() );
75
76 if ( std::less<const error_category*>()( &generic_category(), &system_category() ) )
77 {
78 BOOST_TEST( generic_category() < system_category() );
79 BOOST_TEST( !(system_category() < generic_category()) );
80 }
81 else
82 {
83 BOOST_TEST( system_category() < generic_category() );
84 BOOST_TEST( !(generic_category() < system_category()) );
85 }
86
87
88 error_code ec;
89 error_condition econd;
90 BOOST_TEST( !ec );
91 BOOST_TEST( ec.value() == 0 );
92 econd = ec.default_error_condition();
93 BOOST_TEST( econd.value() == 0 );
94 BOOST_TEST( econd.category() == generic_category() );
95 BOOST_TEST( ec == errc::success );
96 BOOST_TEST( ec.category() == system_category() );
97 BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
98 BOOST_TEST( !(ec < error_code( 0, system_category() )) );
99 BOOST_TEST( !(error_code( 0, system_category() ) < ec) );
100 BOOST_TEST( ec < error_code( 1, system_category() ) );
101 BOOST_TEST( !(error_code( 1, system_category() ) < ec) );
102
103 error_code ec_0_system( 0, system_category() );
104 BOOST_TEST( !ec_0_system );
105 BOOST_TEST( ec_0_system.value() == 0 );
106 econd = ec_0_system.default_error_condition();
107 BOOST_TEST( econd.value() == 0 );
108 BOOST_TEST( econd.category() == generic_category() );
109 BOOST_TEST( ec_0_system == errc::success );
110 BOOST_TEST( ec_0_system.category() == system_category() );
111 BOOST_TEST( std::strcmp( ec_0_system.category().name(), "system") == 0 );
112 check_ostream( ec: ec_0_system, expected: "system:0" );
113
114 BOOST_TEST( ec_0_system == ec );
115
116 error_code ec_1_system( 1, system_category() );
117 BOOST_TEST( ec_1_system );
118 BOOST_TEST( ec_1_system.value() == 1 );
119 BOOST_TEST( ec_1_system.value() != 0 );
120 BOOST_TEST( ec != ec_1_system );
121 BOOST_TEST( ec_0_system != ec_1_system );
122 check_ostream( ec: ec_1_system, expected: "system:1" );
123
124 ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
125 BOOST_TEST( ec );
126 BOOST_TEST( ec.value() == BOOST_ACCESS_ERROR_MACRO );
127 econd = ec.default_error_condition();
128 BOOST_TEST( econd.value() == static_cast<int>(errc::permission_denied) );
129 BOOST_TEST( econd.category() == generic_category() );
130 BOOST_TEST( econd == error_condition( errc::permission_denied, generic_category() ) );
131 BOOST_TEST( econd == errc::permission_denied );
132 BOOST_TEST( errc::permission_denied == econd );
133 BOOST_TEST( ec == errc::permission_denied );
134 BOOST_TEST( ec.category() == system_category() );
135 BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
136
137 // test the explicit make_error_code conversion for errc
138 ec = make_error_code( e: errc::bad_message );
139 BOOST_TEST( ec );
140 BOOST_TEST( ec == errc::bad_message );
141 BOOST_TEST( errc::bad_message == ec );
142 BOOST_TEST( ec != errc::permission_denied );
143 BOOST_TEST( errc::permission_denied != ec );
144 BOOST_TEST( ec.category() == generic_category() );
145
146 //// test the deprecated predefined error_category synonyms
147 //BOOST_TEST( &system_category() == &native_ecat );
148 //BOOST_TEST( &generic_category() == &errno_ecat );
149 //BOOST_TEST( system_category() == native_ecat );
150 //BOOST_TEST( generic_category() == errno_ecat );
151
152 // test error_code and error_condition message();
153 // see Boost.Filesystem operations_test for code specific message() tests
154 ec = error_code( -1, system_category() );
155 std::cout << "error_code message for -1 is \"" << ec.message() << "\"\n";
156 std::cout << "error_code message for 0 is \"" << ec_0_system.message() << "\"\n";
157#if defined(BOOST_WINDOWS_API)
158 // Borland appends newline, so just check text
159 BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
160 BOOST_TEST( ec_0_system.message().substr(0,36) == "The operation completed successfully" );
161#elif defined(linux) || defined(__linux) || defined(__linux__)
162 // Linux appends value to message as unsigned, so it varies with # of bits
163 BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
164#elif defined(__hpux)
165 BOOST_TEST( ec.message() == "" );
166#elif defined(__osf__)
167 BOOST_TEST( ec.message() == "Error -1 occurred." );
168#elif defined(__vms)
169 BOOST_TEST( ec.message() == "error -1" );
170#endif
171
172 ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
173 BOOST_TEST( ec.message() != "" );
174 BOOST_TEST( ec.message().substr( 0, 13) != "Unknown error" );
175
176 econd = error_condition( -1, generic_category() );
177 error_condition econd_ok;
178 std::cout << "error_condition message for -1 is \"" << econd.message() << "\"\n";
179 std::cout << "error_condition message for 0 is \"" << econd_ok.message() << "\"\n";
180#if defined(BOOST_WINDOWS_API)
181 // Borland appends newline, so just check text
182 BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
183 BOOST_TEST( econd_ok.message().substr(0,8) == "No error" );
184#elif defined(linux) || defined(__linux) || defined(__linux__)
185 // Linux appends value to message as unsigned, so it varies with # of bits
186 BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
187#elif defined(__hpux)
188 BOOST_TEST( econd.message() == "" );
189#elif defined(__osf__)
190 BOOST_TEST( econd.message() == "Error -1 occurred." );
191#elif defined(__vms)
192 BOOST_TEST( econd.message() == "error -1" );
193#endif
194
195 econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category() );
196 BOOST_TEST( econd.message() != "" );
197 BOOST_TEST( econd.message().substr( 0, 13) != "Unknown error" );
198
199#ifdef BOOST_WINDOWS_API
200 std::cout << "Windows tests...\n";
201 // these tests probe the Windows errc decoder
202 // test the first entry in the decoder table:
203 ec = error_code( ERROR_ACCESS_DENIED, system_category() );
204 BOOST_TEST( ec.value() == ERROR_ACCESS_DENIED );
205 BOOST_TEST( ec == errc::permission_denied );
206 BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
207 BOOST_TEST( ec.default_error_condition().category() == generic_category() );
208
209 // test the second entry in the decoder table:
210 ec = error_code( ERROR_ALREADY_EXISTS, system_category() );
211 BOOST_TEST( ec.value() == ERROR_ALREADY_EXISTS );
212 BOOST_TEST( ec == errc::file_exists );
213 BOOST_TEST( ec.default_error_condition().value() == errc::file_exists );
214 BOOST_TEST( ec.default_error_condition().category() == generic_category() );
215
216 // test the third entry in the decoder table:
217 ec = error_code( ERROR_BAD_UNIT, system_category() );
218 BOOST_TEST( ec.value() == ERROR_BAD_UNIT );
219 BOOST_TEST( ec == errc::no_such_device );
220 BOOST_TEST( ec.default_error_condition().value() == errc::no_such_device );
221 BOOST_TEST( ec.default_error_condition().category() == generic_category() );
222
223 // test the last non-Winsock entry in the decoder table:
224 ec = error_code( ERROR_WRITE_PROTECT, system_category() );
225 BOOST_TEST( ec.value() == ERROR_WRITE_PROTECT );
226 BOOST_TEST( ec == errc::permission_denied );
227 BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
228 BOOST_TEST( ec.default_error_condition().category() == generic_category() );
229
230 // test the last Winsock entry in the decoder table:
231 ec = error_code( WSAEWOULDBLOCK, system_category() );
232 BOOST_TEST( ec.value() == WSAEWOULDBLOCK );
233 BOOST_TEST( ec == errc::operation_would_block );
234 BOOST_TEST( ec.default_error_condition().value() == errc::operation_would_block );
235 BOOST_TEST( ec.default_error_condition().category() == generic_category() );
236
237 // test not-in-table condition:
238 ec = error_code( 1234567890, system_category() );
239 BOOST_TEST( ec.value() == 1234567890 );
240 BOOST_TEST( ec.default_error_condition().value() == 1234567890 );
241 BOOST_TEST( ec.default_error_condition().category() == system_category() );
242
243#else // POSIX
244
245 std::cout << "POSIX tests...\n";
246 ec = error_code( EACCES, system_category() );
247 BOOST_TEST( ec == error_code( errc::permission_denied, system_category() ) );
248 BOOST_TEST( error_code( errc::permission_denied, system_category() ) == ec );
249 BOOST_TEST( ec == errc::permission_denied );
250 BOOST_TEST( errc::permission_denied == ec );
251 BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
252 BOOST_TEST( ec.default_error_condition().category() == generic_category() );
253
254# ifdef __CYGWIN__
255
256 std::cout << "Cygwin tests...\n";
257 ec = cygwin_error::no_package;
258 BOOST_TEST( ec == cygwin_error::no_package );
259 BOOST_TEST( ec == error_code( ENOPKG, system_category() ) );
260 BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category() ) );
261 BOOST_TEST( ec.default_error_condition().category() == system_category() );
262
263# elif defined(linux) || defined(__linux) || defined(__linux__)
264
265 std::cout << "Linux tests...\n";
266 ec = linux_error::dot_dot_error;
267 BOOST_TEST( ec == linux_error::dot_dot_error );
268 BOOST_TEST( ec == error_code( EDOTDOT, system_category() ) );
269 BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category() ) );
270 BOOST_TEST( ec.default_error_condition().category() == system_category() );
271
272# endif
273
274#endif
275
276 return ::boost::report_errors();
277}
278
279
280

source code of boost/libs/system/test/error_code_test.cpp