summaryrefslogtreecommitdiffstats
path: root/src/fmt/test/posix-mock-test.cc
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-21 11:54:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-21 11:54:28 +0000
commite6918187568dbd01842d8d1d2c808ce16a894239 (patch)
tree64f88b554b444a49f656b6c656111a145cbbaa28 /src/fmt/test/posix-mock-test.cc
parentInitial commit. (diff)
downloadceph-e6918187568dbd01842d8d1d2c808ce16a894239.tar.xz
ceph-e6918187568dbd01842d8d1d2c808ce16a894239.zip
Adding upstream version 18.2.2.upstream/18.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/fmt/test/posix-mock-test.cc')
-rw-r--r--src/fmt/test/posix-mock-test.cc459
1 files changed, 459 insertions, 0 deletions
diff --git a/src/fmt/test/posix-mock-test.cc b/src/fmt/test/posix-mock-test.cc
new file mode 100644
index 000000000..819a94dfb
--- /dev/null
+++ b/src/fmt/test/posix-mock-test.cc
@@ -0,0 +1,459 @@
+// Tests of the C++ interface to POSIX functions that require mocks
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Disable bogus MSVC warnings.
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+# define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "posix-mock.h"
+
+#include <errno.h>
+#include <fcntl.h>
+
+#include <climits>
+#include <memory>
+
+#include "../src/os.cc"
+
+#ifdef _WIN32
+# include <io.h>
+# undef max
+#endif
+
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+using fmt::buffered_file;
+
+using testing::_;
+using testing::Return;
+using testing::StrEq;
+
+template <typename Mock> struct scoped_mock : testing::StrictMock<Mock> {
+ scoped_mock() { Mock::instance = this; }
+ ~scoped_mock() { Mock::instance = nullptr; }
+};
+
+namespace {
+int open_count;
+int close_count;
+int dup_count;
+int dup2_count;
+int fdopen_count;
+int read_count;
+int write_count;
+int pipe_count;
+int fopen_count;
+int fclose_count;
+int fileno_count;
+size_t read_nbyte;
+size_t write_nbyte;
+bool sysconf_error;
+
+enum { none, max_size, error } fstat_sim;
+} // namespace
+
+#define EMULATE_EINTR(func, error_result) \
+ if (func##_count != 0) { \
+ if (func##_count++ != 3) { \
+ errno = EINTR; \
+ return error_result; \
+ } \
+ }
+
+#ifndef _MSC_VER
+int test::open(const char* path, int oflag, int mode) {
+ EMULATE_EINTR(open, -1);
+ return ::open(path, oflag, mode);
+}
+#else
+errno_t test::sopen_s(int* pfh, const char* filename, int oflag, int shflag,
+ int pmode) {
+ EMULATE_EINTR(open, EINTR);
+ return _sopen_s(pfh, filename, oflag, shflag, pmode);
+}
+#endif
+
+#ifndef _WIN32
+
+long test::sysconf(int name) {
+ long result = ::sysconf(name);
+ if (!sysconf_error) return result;
+ // Simulate an error.
+ errno = EINVAL;
+ return -1;
+}
+
+static off_t max_file_size() { return std::numeric_limits<off_t>::max(); }
+
+int test::fstat(int fd, struct stat* buf) {
+ int result = ::fstat(fd, buf);
+ if (fstat_sim == max_size) buf->st_size = max_file_size();
+ return result;
+}
+
+#else
+
+static LONGLONG max_file_size() { return std::numeric_limits<LONGLONG>::max(); }
+
+DWORD test::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
+ if (fstat_sim == error) {
+ SetLastError(ERROR_ACCESS_DENIED);
+ return INVALID_FILE_SIZE;
+ }
+ if (fstat_sim == max_size) {
+ DWORD max = std::numeric_limits<DWORD>::max();
+ *lpFileSizeHigh = max >> 1;
+ return max;
+ }
+ return ::GetFileSize(hFile, lpFileSizeHigh);
+}
+
+#endif
+
+int test::close(int fildes) {
+ // Close the file first because close shouldn't be retried.
+ int result = ::FMT_POSIX(close(fildes));
+ EMULATE_EINTR(close, -1);
+ return result;
+}
+
+int test::dup(int fildes) {
+ EMULATE_EINTR(dup, -1);
+ return ::FMT_POSIX(dup(fildes));
+}
+
+int test::dup2(int fildes, int fildes2) {
+ EMULATE_EINTR(dup2, -1);
+ return ::FMT_POSIX(dup2(fildes, fildes2));
+}
+
+FILE* test::fdopen(int fildes, const char* mode) {
+ EMULATE_EINTR(fdopen, nullptr);
+ return ::FMT_POSIX(fdopen(fildes, mode));
+}
+
+test::ssize_t test::read(int fildes, void* buf, test::size_t nbyte) {
+ read_nbyte = nbyte;
+ EMULATE_EINTR(read, -1);
+ return ::FMT_POSIX(read(fildes, buf, nbyte));
+}
+
+test::ssize_t test::write(int fildes, const void* buf, test::size_t nbyte) {
+ write_nbyte = nbyte;
+ EMULATE_EINTR(write, -1);
+ return ::FMT_POSIX(write(fildes, buf, nbyte));
+}
+
+#ifndef _WIN32
+int test::pipe(int fildes[2]) {
+ EMULATE_EINTR(pipe, -1);
+ return ::pipe(fildes);
+}
+#else
+int test::pipe(int* pfds, unsigned psize, int textmode) {
+ EMULATE_EINTR(pipe, -1);
+ return _pipe(pfds, psize, textmode);
+}
+#endif
+
+FILE* test::fopen(const char* filename, const char* mode) {
+ EMULATE_EINTR(fopen, nullptr);
+ return ::fopen(filename, mode);
+}
+
+int test::fclose(FILE* stream) {
+ EMULATE_EINTR(fclose, EOF);
+ return ::fclose(stream);
+}
+
+int(test::fileno)(FILE* stream) {
+ EMULATE_EINTR(fileno, -1);
+#ifdef fileno
+ return FMT_POSIX(fileno(stream));
+#else
+ return ::FMT_POSIX(fileno(stream));
+#endif
+}
+
+#ifndef _WIN32
+# define EXPECT_RETRY(statement, func, message) \
+ func##_count = 1; \
+ statement; \
+ EXPECT_EQ(4, func##_count); \
+ func##_count = 0;
+# define EXPECT_EQ_POSIX(expected, actual) EXPECT_EQ(expected, actual)
+#else
+# define EXPECT_RETRY(statement, func, message) \
+ func##_count = 1; \
+ EXPECT_SYSTEM_ERROR(statement, EINTR, message); \
+ func##_count = 0;
+# define EXPECT_EQ_POSIX(expected, actual)
+#endif
+
+#if FMT_USE_FCNTL
+void write_file(fmt::cstring_view filename, fmt::string_view content) {
+ fmt::buffered_file f(filename, "w");
+ f.print("{}", content);
+}
+
+using fmt::file;
+
+TEST(os_test, getpagesize) {
+# ifdef _WIN32
+ SYSTEM_INFO si = {};
+ GetSystemInfo(&si);
+ EXPECT_EQ(si.dwPageSize, fmt::getpagesize());
+# else
+ EXPECT_EQ(sysconf(_SC_PAGESIZE), fmt::getpagesize());
+ sysconf_error = true;
+ EXPECT_SYSTEM_ERROR(fmt::getpagesize(), EINVAL,
+ "cannot get memory page size");
+ sysconf_error = false;
+# endif
+}
+
+TEST(file_test, open_retry) {
+ write_file("temp", "there must be something here");
+ std::unique_ptr<file> f{nullptr};
+ EXPECT_RETRY(f.reset(new file("temp", file::RDONLY)), open,
+ "cannot open file temp");
+# ifndef _WIN32
+ char c = 0;
+ f->read(&c, 1);
+# endif
+}
+
+TEST(file_test, close_no_retry_in_dtor) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ std::unique_ptr<file> f(new file(std::move(read_end)));
+ int saved_close_count = 0;
+ EXPECT_WRITE(
+ stderr,
+ {
+ close_count = 1;
+ f.reset(nullptr);
+ saved_close_count = close_count;
+ close_count = 0;
+ },
+ system_error_message(EINTR, "cannot close file") + "\n");
+ EXPECT_EQ(2, saved_close_count);
+}
+
+TEST(file_test, close_no_retry) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ close_count = 1;
+ EXPECT_SYSTEM_ERROR(read_end.close(), EINTR, "cannot close file");
+ EXPECT_EQ(2, close_count);
+ close_count = 0;
+}
+
+TEST(file_test, size) {
+ std::string content = "top secret, destroy before reading";
+ write_file("temp", content);
+ file f("temp", file::RDONLY);
+ EXPECT_GE(f.size(), 0);
+ EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
+# ifdef _WIN32
+ auto error_code = std::error_code();
+ fstat_sim = error;
+ try {
+ f.size();
+ } catch (const std::system_error& e) {
+ error_code = e.code();
+ }
+ fstat_sim = none;
+ EXPECT_EQ(error_code,
+ std::error_code(ERROR_ACCESS_DENIED, fmt::system_category()));
+# else
+ f.close();
+ EXPECT_SYSTEM_ERROR(f.size(), EBADF, "cannot get file attributes");
+# endif
+}
+
+TEST(file_test, max_size) {
+ write_file("temp", "");
+ file f("temp", file::RDONLY);
+ fstat_sim = max_size;
+ EXPECT_GE(f.size(), 0);
+ EXPECT_EQ(max_file_size(), f.size());
+ fstat_sim = none;
+}
+
+TEST(file_test, read_retry) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ enum { SIZE = 4 };
+ write_end.write("test", SIZE);
+ write_end.close();
+ char buffer[SIZE];
+ size_t count = 0;
+ EXPECT_RETRY(count = read_end.read(buffer, SIZE), read,
+ "cannot read from file");
+ EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count);
+}
+
+TEST(file_test, write_retry) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ enum { SIZE = 4 };
+ size_t count = 0;
+ EXPECT_RETRY(count = write_end.write("test", SIZE), write,
+ "cannot write to file");
+ write_end.close();
+# ifndef _WIN32
+ EXPECT_EQ(static_cast<std::streamsize>(SIZE), count);
+ char buffer[SIZE + 1];
+ read_end.read(buffer, SIZE);
+ buffer[SIZE] = '\0';
+ EXPECT_STREQ("test", buffer);
+# endif
+}
+
+# ifdef _WIN32
+TEST(file_test, convert_read_count) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ char c;
+ size_t size = UINT_MAX;
+ if (sizeof(unsigned) != sizeof(size_t)) ++size;
+ read_count = 1;
+ read_nbyte = 0;
+ EXPECT_THROW(read_end.read(&c, size), std::system_error);
+ read_count = 0;
+ EXPECT_EQ(UINT_MAX, read_nbyte);
+}
+
+TEST(file_test, convert_write_count) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ char c;
+ size_t size = UINT_MAX;
+ if (sizeof(unsigned) != sizeof(size_t)) ++size;
+ write_count = 1;
+ write_nbyte = 0;
+ EXPECT_THROW(write_end.write(&c, size), std::system_error);
+ write_count = 0;
+ EXPECT_EQ(UINT_MAX, write_nbyte);
+}
+# endif
+
+TEST(file_test, dup_no_retry) {
+ int stdout_fd = FMT_POSIX(fileno(stdout));
+ dup_count = 1;
+ EXPECT_SYSTEM_ERROR(
+ file::dup(stdout_fd), EINTR,
+ fmt::format("cannot duplicate file descriptor {}", stdout_fd));
+ dup_count = 0;
+}
+
+TEST(file_test, dup2_retry) {
+ int stdout_fd = FMT_POSIX(fileno(stdout));
+ file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+ EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2,
+ fmt::format("cannot duplicate file descriptor {} to {}",
+ f1.descriptor(), f2.descriptor()));
+}
+
+TEST(file_test, dup2_no_except_retry) {
+ int stdout_fd = FMT_POSIX(fileno(stdout));
+ file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+ std::error_code ec;
+ dup2_count = 1;
+ f1.dup2(f2.descriptor(), ec);
+# ifndef _WIN32
+ EXPECT_EQ(4, dup2_count);
+# else
+ EXPECT_EQ(EINTR, ec.value());
+# endif
+ dup2_count = 0;
+}
+
+TEST(file_test, pipe_no_retry) {
+ file read_end, write_end;
+ pipe_count = 1;
+ EXPECT_SYSTEM_ERROR(file::pipe(read_end, write_end), EINTR,
+ "cannot create pipe");
+ pipe_count = 0;
+}
+
+TEST(file_test, fdopen_no_retry) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ fdopen_count = 1;
+ EXPECT_SYSTEM_ERROR(read_end.fdopen("r"), EINTR,
+ "cannot associate stream with file descriptor");
+ fdopen_count = 0;
+}
+
+TEST(buffered_file_test, open_retry) {
+ write_file("temp", "there must be something here");
+ std::unique_ptr<buffered_file> f{nullptr};
+ EXPECT_RETRY(f.reset(new buffered_file("temp", "r")), fopen,
+ "cannot open file temp");
+# ifndef _WIN32
+ char c = 0;
+ if (fread(&c, 1, 1, f->get()) < 1)
+ throw fmt::system_error(errno, "fread failed");
+# endif
+}
+
+TEST(buffered_file_test, close_no_retry_in_dtor) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ std::unique_ptr<buffered_file> f(new buffered_file(read_end.fdopen("r")));
+ int saved_fclose_count = 0;
+ EXPECT_WRITE(
+ stderr,
+ {
+ fclose_count = 1;
+ f.reset(nullptr);
+ saved_fclose_count = fclose_count;
+ fclose_count = 0;
+ },
+ system_error_message(EINTR, "cannot close file") + "\n");
+ EXPECT_EQ(2, saved_fclose_count);
+}
+
+TEST(buffered_file_test, close_no_retry) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ buffered_file f = read_end.fdopen("r");
+ fclose_count = 1;
+ EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file");
+ EXPECT_EQ(2, fclose_count);
+ fclose_count = 0;
+}
+
+TEST(buffered_file_test, fileno_no_retry) {
+ file read_end, write_end;
+ file::pipe(read_end, write_end);
+ buffered_file f = read_end.fdopen("r");
+ fileno_count = 1;
+ EXPECT_SYSTEM_ERROR((f.descriptor)(), EINTR, "cannot get file descriptor");
+ EXPECT_EQ(2, fileno_count);
+ fileno_count = 0;
+}
+#endif // FMT_USE_FCNTL
+
+struct test_mock {
+ static test_mock* instance;
+} * test_mock::instance;
+
+TEST(scoped_mock, scope) {
+ {
+ scoped_mock<test_mock> mock;
+ EXPECT_EQ(&mock, test_mock::instance);
+ test_mock& copy = mock;
+ static_cast<void>(copy);
+ }
+ EXPECT_EQ(nullptr, test_mock::instance);
+}