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. |
31 | using 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 | |
42 | namespace |
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 | |
59 | int 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 | |