]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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(errc::file_exists); | |
66 | make_error_condition(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_0_system, "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_1_system, "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( 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 |