]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
1 | // Tests of the C++ interface to POSIX functions that require mocks |
2 | // | |
3 | // Copyright (c) 2012 - present, Victor Zverovich | |
4 | // All rights reserved. | |
5 | // | |
6 | // For the license information refer to format.h. | |
7 | ||
8 | // Disable bogus MSVC warnings. | |
1e59de90 | 9 | #if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER) |
9f95a23c | 10 | # define _CRT_SECURE_NO_WARNINGS |
11fdf7f2 TL |
11 | #endif |
12 | ||
13 | #include "posix-mock.h" | |
11fdf7f2 TL |
14 | |
15 | #include <errno.h> | |
16 | #include <fcntl.h> | |
f67539c2 | 17 | |
11fdf7f2 | 18 | #include <climits> |
9f95a23c | 19 | #include <memory> |
11fdf7f2 | 20 | |
f67539c2 TL |
21 | #include "../src/os.cc" |
22 | ||
11fdf7f2 | 23 | #ifdef _WIN32 |
9f95a23c TL |
24 | # include <io.h> |
25 | # undef max | |
11fdf7f2 TL |
26 | #endif |
27 | ||
20effc67 | 28 | #include "gmock/gmock.h" |
11fdf7f2 TL |
29 | #include "gtest-extra.h" |
30 | #include "util.h" | |
31 | ||
32 | using fmt::buffered_file; | |
11fdf7f2 | 33 | |
11fdf7f2 | 34 | using testing::_; |
11fdf7f2 | 35 | using testing::Return; |
9f95a23c | 36 | using testing::StrEq; |
11fdf7f2 | 37 | |
20effc67 TL |
38 | template <typename Mock> struct scoped_mock : testing::StrictMock<Mock> { |
39 | scoped_mock() { Mock::instance = this; } | |
40 | ~scoped_mock() { Mock::instance = nullptr; } | |
41 | }; | |
42 | ||
11fdf7f2 TL |
43 | namespace { |
44 | int open_count; | |
45 | int close_count; | |
46 | int dup_count; | |
47 | int dup2_count; | |
48 | int fdopen_count; | |
49 | int read_count; | |
50 | int write_count; | |
51 | int pipe_count; | |
52 | int fopen_count; | |
53 | int fclose_count; | |
54 | int fileno_count; | |
f67539c2 TL |
55 | size_t read_nbyte; |
56 | size_t write_nbyte; | |
11fdf7f2 TL |
57 | bool sysconf_error; |
58 | ||
20effc67 | 59 | enum { none, max_size, error } fstat_sim; |
9f95a23c | 60 | } // namespace |
11fdf7f2 TL |
61 | |
62 | #define EMULATE_EINTR(func, error_result) \ | |
9f95a23c TL |
63 | if (func##_count != 0) { \ |
64 | if (func##_count++ != 3) { \ | |
65 | errno = EINTR; \ | |
66 | return error_result; \ | |
67 | } \ | |
11fdf7f2 TL |
68 | } |
69 | ||
70 | #ifndef _MSC_VER | |
9f95a23c | 71 | int test::open(const char* path, int oflag, int mode) { |
11fdf7f2 TL |
72 | EMULATE_EINTR(open, -1); |
73 | return ::open(path, oflag, mode); | |
74 | } | |
75 | #else | |
9f95a23c TL |
76 | errno_t test::sopen_s(int* pfh, const char* filename, int oflag, int shflag, |
77 | int pmode) { | |
11fdf7f2 TL |
78 | EMULATE_EINTR(open, EINTR); |
79 | return _sopen_s(pfh, filename, oflag, shflag, pmode); | |
80 | } | |
81 | #endif | |
82 | ||
83 | #ifndef _WIN32 | |
84 | ||
85 | long test::sysconf(int name) { | |
86 | long result = ::sysconf(name); | |
9f95a23c | 87 | if (!sysconf_error) return result; |
11fdf7f2 TL |
88 | // Simulate an error. |
89 | errno = EINVAL; | |
90 | return -1; | |
91 | } | |
92 | ||
93 | static off_t max_file_size() { return std::numeric_limits<off_t>::max(); } | |
94 | ||
9f95a23c | 95 | int test::fstat(int fd, struct stat* buf) { |
11fdf7f2 | 96 | int result = ::fstat(fd, buf); |
20effc67 | 97 | if (fstat_sim == max_size) buf->st_size = max_file_size(); |
11fdf7f2 TL |
98 | return result; |
99 | } | |
100 | ||
101 | #else | |
102 | ||
103 | static LONGLONG max_file_size() { return std::numeric_limits<LONGLONG>::max(); } | |
104 | ||
105 | DWORD test::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) { | |
20effc67 | 106 | if (fstat_sim == error) { |
11fdf7f2 TL |
107 | SetLastError(ERROR_ACCESS_DENIED); |
108 | return INVALID_FILE_SIZE; | |
109 | } | |
20effc67 | 110 | if (fstat_sim == max_size) { |
11fdf7f2 TL |
111 | DWORD max = std::numeric_limits<DWORD>::max(); |
112 | *lpFileSizeHigh = max >> 1; | |
113 | return max; | |
114 | } | |
115 | return ::GetFileSize(hFile, lpFileSizeHigh); | |
116 | } | |
117 | ||
118 | #endif | |
119 | ||
120 | int test::close(int fildes) { | |
121 | // Close the file first because close shouldn't be retried. | |
122 | int result = ::FMT_POSIX(close(fildes)); | |
123 | EMULATE_EINTR(close, -1); | |
124 | return result; | |
125 | } | |
126 | ||
127 | int test::dup(int fildes) { | |
128 | EMULATE_EINTR(dup, -1); | |
129 | return ::FMT_POSIX(dup(fildes)); | |
130 | } | |
131 | ||
132 | int test::dup2(int fildes, int fildes2) { | |
133 | EMULATE_EINTR(dup2, -1); | |
134 | return ::FMT_POSIX(dup2(fildes, fildes2)); | |
135 | } | |
136 | ||
9f95a23c | 137 | FILE* test::fdopen(int fildes, const char* mode) { |
f67539c2 | 138 | EMULATE_EINTR(fdopen, nullptr); |
11fdf7f2 TL |
139 | return ::FMT_POSIX(fdopen(fildes, mode)); |
140 | } | |
141 | ||
9f95a23c | 142 | test::ssize_t test::read(int fildes, void* buf, test::size_t nbyte) { |
11fdf7f2 TL |
143 | read_nbyte = nbyte; |
144 | EMULATE_EINTR(read, -1); | |
145 | return ::FMT_POSIX(read(fildes, buf, nbyte)); | |
146 | } | |
147 | ||
9f95a23c | 148 | test::ssize_t test::write(int fildes, const void* buf, test::size_t nbyte) { |
11fdf7f2 TL |
149 | write_nbyte = nbyte; |
150 | EMULATE_EINTR(write, -1); | |
151 | return ::FMT_POSIX(write(fildes, buf, nbyte)); | |
152 | } | |
153 | ||
154 | #ifndef _WIN32 | |
155 | int test::pipe(int fildes[2]) { | |
156 | EMULATE_EINTR(pipe, -1); | |
157 | return ::pipe(fildes); | |
158 | } | |
159 | #else | |
9f95a23c | 160 | int test::pipe(int* pfds, unsigned psize, int textmode) { |
11fdf7f2 TL |
161 | EMULATE_EINTR(pipe, -1); |
162 | return _pipe(pfds, psize, textmode); | |
163 | } | |
164 | #endif | |
165 | ||
9f95a23c | 166 | FILE* test::fopen(const char* filename, const char* mode) { |
f67539c2 | 167 | EMULATE_EINTR(fopen, nullptr); |
11fdf7f2 TL |
168 | return ::fopen(filename, mode); |
169 | } | |
170 | ||
9f95a23c | 171 | int test::fclose(FILE* stream) { |
11fdf7f2 TL |
172 | EMULATE_EINTR(fclose, EOF); |
173 | return ::fclose(stream); | |
174 | } | |
175 | ||
9f95a23c | 176 | int(test::fileno)(FILE* stream) { |
11fdf7f2 TL |
177 | EMULATE_EINTR(fileno, -1); |
178 | #ifdef fileno | |
179 | return FMT_POSIX(fileno(stream)); | |
180 | #else | |
181 | return ::FMT_POSIX(fileno(stream)); | |
182 | #endif | |
183 | } | |
184 | ||
185 | #ifndef _WIN32 | |
9f95a23c TL |
186 | # define EXPECT_RETRY(statement, func, message) \ |
187 | func##_count = 1; \ | |
188 | statement; \ | |
189 | EXPECT_EQ(4, func##_count); \ | |
11fdf7f2 | 190 | func##_count = 0; |
9f95a23c | 191 | # define EXPECT_EQ_POSIX(expected, actual) EXPECT_EQ(expected, actual) |
11fdf7f2 | 192 | #else |
9f95a23c TL |
193 | # define EXPECT_RETRY(statement, func, message) \ |
194 | func##_count = 1; \ | |
11fdf7f2 TL |
195 | EXPECT_SYSTEM_ERROR(statement, EINTR, message); \ |
196 | func##_count = 0; | |
9f95a23c | 197 | # define EXPECT_EQ_POSIX(expected, actual) |
11fdf7f2 TL |
198 | #endif |
199 | ||
20effc67 TL |
200 | #if FMT_USE_FCNTL |
201 | void write_file(fmt::cstring_view filename, fmt::string_view content) { | |
11fdf7f2 TL |
202 | fmt::buffered_file f(filename, "w"); |
203 | f.print("{}", content); | |
204 | } | |
205 | ||
f67539c2 TL |
206 | using fmt::file; |
207 | ||
20effc67 | 208 | TEST(os_test, getpagesize) { |
f67539c2 | 209 | # ifdef _WIN32 |
11fdf7f2 TL |
210 | SYSTEM_INFO si = {}; |
211 | GetSystemInfo(&si); | |
212 | EXPECT_EQ(si.dwPageSize, fmt::getpagesize()); | |
f67539c2 | 213 | # else |
11fdf7f2 TL |
214 | EXPECT_EQ(sysconf(_SC_PAGESIZE), fmt::getpagesize()); |
215 | sysconf_error = true; | |
9f95a23c TL |
216 | EXPECT_SYSTEM_ERROR(fmt::getpagesize(), EINVAL, |
217 | "cannot get memory page size"); | |
11fdf7f2 | 218 | sysconf_error = false; |
f67539c2 | 219 | # endif |
11fdf7f2 TL |
220 | } |
221 | ||
20effc67 | 222 | TEST(file_test, open_retry) { |
f67539c2 TL |
223 | write_file("temp", "there must be something here"); |
224 | std::unique_ptr<file> f{nullptr}; | |
225 | EXPECT_RETRY(f.reset(new file("temp", file::RDONLY)), open, | |
226 | "cannot open file temp"); | |
227 | # ifndef _WIN32 | |
11fdf7f2 TL |
228 | char c = 0; |
229 | f->read(&c, 1); | |
f67539c2 | 230 | # endif |
11fdf7f2 TL |
231 | } |
232 | ||
20effc67 | 233 | TEST(file_test, close_no_retry_in_dtor) { |
11fdf7f2 TL |
234 | file read_end, write_end; |
235 | file::pipe(read_end, write_end); | |
9f95a23c | 236 | std::unique_ptr<file> f(new file(std::move(read_end))); |
11fdf7f2 | 237 | int saved_close_count = 0; |
f67539c2 TL |
238 | EXPECT_WRITE( |
239 | stderr, | |
240 | { | |
241 | close_count = 1; | |
242 | f.reset(nullptr); | |
243 | saved_close_count = close_count; | |
244 | close_count = 0; | |
245 | }, | |
20effc67 | 246 | system_error_message(EINTR, "cannot close file") + "\n"); |
11fdf7f2 TL |
247 | EXPECT_EQ(2, saved_close_count); |
248 | } | |
249 | ||
20effc67 | 250 | TEST(file_test, close_no_retry) { |
11fdf7f2 TL |
251 | file read_end, write_end; |
252 | file::pipe(read_end, write_end); | |
253 | close_count = 1; | |
254 | EXPECT_SYSTEM_ERROR(read_end.close(), EINTR, "cannot close file"); | |
255 | EXPECT_EQ(2, close_count); | |
256 | close_count = 0; | |
257 | } | |
258 | ||
20effc67 | 259 | TEST(file_test, size) { |
11fdf7f2 | 260 | std::string content = "top secret, destroy before reading"; |
f67539c2 TL |
261 | write_file("temp", content); |
262 | file f("temp", file::RDONLY); | |
11fdf7f2 TL |
263 | EXPECT_GE(f.size(), 0); |
264 | EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size())); | |
f67539c2 | 265 | # ifdef _WIN32 |
20effc67 TL |
266 | auto error_code = std::error_code(); |
267 | fstat_sim = error; | |
268 | try { | |
269 | f.size(); | |
270 | } catch (const std::system_error& e) { | |
271 | error_code = e.code(); | |
272 | } | |
273 | fstat_sim = none; | |
274 | EXPECT_EQ(error_code, | |
275 | std::error_code(ERROR_ACCESS_DENIED, fmt::system_category())); | |
f67539c2 | 276 | # else |
11fdf7f2 TL |
277 | f.close(); |
278 | EXPECT_SYSTEM_ERROR(f.size(), EBADF, "cannot get file attributes"); | |
f67539c2 | 279 | # endif |
11fdf7f2 TL |
280 | } |
281 | ||
20effc67 | 282 | TEST(file_test, max_size) { |
f67539c2 TL |
283 | write_file("temp", ""); |
284 | file f("temp", file::RDONLY); | |
20effc67 | 285 | fstat_sim = max_size; |
11fdf7f2 TL |
286 | EXPECT_GE(f.size(), 0); |
287 | EXPECT_EQ(max_file_size(), f.size()); | |
20effc67 | 288 | fstat_sim = none; |
11fdf7f2 TL |
289 | } |
290 | ||
20effc67 | 291 | TEST(file_test, read_retry) { |
11fdf7f2 TL |
292 | file read_end, write_end; |
293 | file::pipe(read_end, write_end); | |
294 | enum { SIZE = 4 }; | |
295 | write_end.write("test", SIZE); | |
296 | write_end.close(); | |
297 | char buffer[SIZE]; | |
f67539c2 | 298 | size_t count = 0; |
9f95a23c TL |
299 | EXPECT_RETRY(count = read_end.read(buffer, SIZE), read, |
300 | "cannot read from file"); | |
11fdf7f2 TL |
301 | EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count); |
302 | } | |
303 | ||
20effc67 | 304 | TEST(file_test, write_retry) { |
11fdf7f2 TL |
305 | file read_end, write_end; |
306 | file::pipe(read_end, write_end); | |
307 | enum { SIZE = 4 }; | |
f67539c2 | 308 | size_t count = 0; |
9f95a23c TL |
309 | EXPECT_RETRY(count = write_end.write("test", SIZE), write, |
310 | "cannot write to file"); | |
11fdf7f2 | 311 | write_end.close(); |
f67539c2 | 312 | # ifndef _WIN32 |
11fdf7f2 TL |
313 | EXPECT_EQ(static_cast<std::streamsize>(SIZE), count); |
314 | char buffer[SIZE + 1]; | |
315 | read_end.read(buffer, SIZE); | |
316 | buffer[SIZE] = '\0'; | |
317 | EXPECT_STREQ("test", buffer); | |
f67539c2 | 318 | # endif |
11fdf7f2 TL |
319 | } |
320 | ||
f67539c2 | 321 | # ifdef _WIN32 |
20effc67 | 322 | TEST(file_test, convert_read_count) { |
11fdf7f2 TL |
323 | file read_end, write_end; |
324 | file::pipe(read_end, write_end); | |
325 | char c; | |
f67539c2 TL |
326 | size_t size = UINT_MAX; |
327 | if (sizeof(unsigned) != sizeof(size_t)) ++size; | |
11fdf7f2 TL |
328 | read_count = 1; |
329 | read_nbyte = 0; | |
20effc67 | 330 | EXPECT_THROW(read_end.read(&c, size), std::system_error); |
11fdf7f2 TL |
331 | read_count = 0; |
332 | EXPECT_EQ(UINT_MAX, read_nbyte); | |
333 | } | |
334 | ||
20effc67 | 335 | TEST(file_test, convert_write_count) { |
11fdf7f2 TL |
336 | file read_end, write_end; |
337 | file::pipe(read_end, write_end); | |
338 | char c; | |
f67539c2 TL |
339 | size_t size = UINT_MAX; |
340 | if (sizeof(unsigned) != sizeof(size_t)) ++size; | |
11fdf7f2 TL |
341 | write_count = 1; |
342 | write_nbyte = 0; | |
20effc67 | 343 | EXPECT_THROW(write_end.write(&c, size), std::system_error); |
11fdf7f2 TL |
344 | write_count = 0; |
345 | EXPECT_EQ(UINT_MAX, write_nbyte); | |
346 | } | |
f67539c2 | 347 | # endif |
11fdf7f2 | 348 | |
20effc67 | 349 | TEST(file_test, dup_no_retry) { |
11fdf7f2 TL |
350 | int stdout_fd = FMT_POSIX(fileno(stdout)); |
351 | dup_count = 1; | |
9f95a23c TL |
352 | EXPECT_SYSTEM_ERROR( |
353 | file::dup(stdout_fd), EINTR, | |
11fdf7f2 TL |
354 | fmt::format("cannot duplicate file descriptor {}", stdout_fd)); |
355 | dup_count = 0; | |
356 | } | |
357 | ||
20effc67 | 358 | TEST(file_test, dup2_retry) { |
11fdf7f2 TL |
359 | int stdout_fd = FMT_POSIX(fileno(stdout)); |
360 | file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd); | |
361 | EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2, | |
9f95a23c TL |
362 | fmt::format("cannot duplicate file descriptor {} to {}", |
363 | f1.descriptor(), f2.descriptor())); | |
11fdf7f2 TL |
364 | } |
365 | ||
20effc67 | 366 | TEST(file_test, dup2_no_except_retry) { |
11fdf7f2 TL |
367 | int stdout_fd = FMT_POSIX(fileno(stdout)); |
368 | file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd); | |
20effc67 | 369 | std::error_code ec; |
11fdf7f2 TL |
370 | dup2_count = 1; |
371 | f1.dup2(f2.descriptor(), ec); | |
f67539c2 | 372 | # ifndef _WIN32 |
11fdf7f2 | 373 | EXPECT_EQ(4, dup2_count); |
f67539c2 | 374 | # else |
20effc67 | 375 | EXPECT_EQ(EINTR, ec.value()); |
f67539c2 | 376 | # endif |
11fdf7f2 TL |
377 | dup2_count = 0; |
378 | } | |
379 | ||
20effc67 | 380 | TEST(file_test, pipe_no_retry) { |
11fdf7f2 TL |
381 | file read_end, write_end; |
382 | pipe_count = 1; | |
9f95a23c TL |
383 | EXPECT_SYSTEM_ERROR(file::pipe(read_end, write_end), EINTR, |
384 | "cannot create pipe"); | |
11fdf7f2 TL |
385 | pipe_count = 0; |
386 | } | |
387 | ||
20effc67 | 388 | TEST(file_test, fdopen_no_retry) { |
11fdf7f2 TL |
389 | file read_end, write_end; |
390 | file::pipe(read_end, write_end); | |
391 | fdopen_count = 1; | |
9f95a23c TL |
392 | EXPECT_SYSTEM_ERROR(read_end.fdopen("r"), EINTR, |
393 | "cannot associate stream with file descriptor"); | |
11fdf7f2 TL |
394 | fdopen_count = 0; |
395 | } | |
396 | ||
20effc67 | 397 | TEST(buffered_file_test, open_retry) { |
f67539c2 TL |
398 | write_file("temp", "there must be something here"); |
399 | std::unique_ptr<buffered_file> f{nullptr}; | |
400 | EXPECT_RETRY(f.reset(new buffered_file("temp", "r")), fopen, | |
401 | "cannot open file temp"); | |
402 | # ifndef _WIN32 | |
11fdf7f2 TL |
403 | char c = 0; |
404 | if (fread(&c, 1, 1, f->get()) < 1) | |
405 | throw fmt::system_error(errno, "fread failed"); | |
f67539c2 | 406 | # endif |
11fdf7f2 TL |
407 | } |
408 | ||
20effc67 | 409 | TEST(buffered_file_test, close_no_retry_in_dtor) { |
11fdf7f2 TL |
410 | file read_end, write_end; |
411 | file::pipe(read_end, write_end); | |
9f95a23c | 412 | std::unique_ptr<buffered_file> f(new buffered_file(read_end.fdopen("r"))); |
11fdf7f2 | 413 | int saved_fclose_count = 0; |
f67539c2 TL |
414 | EXPECT_WRITE( |
415 | stderr, | |
416 | { | |
417 | fclose_count = 1; | |
418 | f.reset(nullptr); | |
419 | saved_fclose_count = fclose_count; | |
420 | fclose_count = 0; | |
421 | }, | |
20effc67 | 422 | system_error_message(EINTR, "cannot close file") + "\n"); |
11fdf7f2 TL |
423 | EXPECT_EQ(2, saved_fclose_count); |
424 | } | |
425 | ||
20effc67 | 426 | TEST(buffered_file_test, close_no_retry) { |
11fdf7f2 TL |
427 | file read_end, write_end; |
428 | file::pipe(read_end, write_end); | |
429 | buffered_file f = read_end.fdopen("r"); | |
430 | fclose_count = 1; | |
431 | EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file"); | |
432 | EXPECT_EQ(2, fclose_count); | |
433 | fclose_count = 0; | |
434 | } | |
435 | ||
20effc67 | 436 | TEST(buffered_file_test, fileno_no_retry) { |
11fdf7f2 TL |
437 | file read_end, write_end; |
438 | file::pipe(read_end, write_end); | |
439 | buffered_file f = read_end.fdopen("r"); | |
440 | fileno_count = 1; | |
1e59de90 | 441 | EXPECT_SYSTEM_ERROR((f.descriptor)(), EINTR, "cannot get file descriptor"); |
11fdf7f2 TL |
442 | EXPECT_EQ(2, fileno_count); |
443 | fileno_count = 0; | |
444 | } | |
f67539c2 | 445 | #endif // FMT_USE_FCNTL |
11fdf7f2 | 446 | |
f67539c2 TL |
447 | struct test_mock { |
448 | static test_mock* instance; | |
449 | } * test_mock::instance; | |
11fdf7f2 | 450 | |
20effc67 | 451 | TEST(scoped_mock, scope) { |
11fdf7f2 | 452 | { |
20effc67 | 453 | scoped_mock<test_mock> mock; |
f67539c2 TL |
454 | EXPECT_EQ(&mock, test_mock::instance); |
455 | test_mock& copy = mock; | |
11fdf7f2 TL |
456 | static_cast<void>(copy); |
457 | } | |
f67539c2 | 458 | EXPECT_EQ(nullptr, test_mock::instance); |
11fdf7f2 | 459 | } |