fmt/test/os-test.cc

527 lines
14 KiB
C++
Raw Normal View History

2019-12-15 22:51:37 +00:00
// Formatting library for C++ - tests of the OS-specific functionality
2018-03-04 17:16:51 +00:00
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
2020-05-07 22:59:46 +00:00
#include "fmt/os.h"
#include <cstdlib> // std::exit
#include <cstring>
#include <memory>
#include "gtest-extra.h"
#include "util.h"
#ifdef fileno
2019-01-13 02:27:38 +00:00
# undef fileno
2015-06-24 18:36:28 +00:00
#endif
2018-05-19 15:57:31 +00:00
using fmt::buffered_file;
2018-05-19 17:32:53 +00:00
using fmt::error_code;
2019-11-15 13:41:14 +00:00
#ifdef _WIN32
2019-12-21 21:10:45 +00:00
# include <windows.h>
TEST(UtilTest, UTF16ToUTF8) {
std::string s = "ёжик";
2020-05-10 14:25:42 +00:00
fmt::detail::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
EXPECT_EQ(s, u.str());
EXPECT_EQ(s.size(), u.size());
}
TEST(UtilTest, UTF16ToUTF8EmptyString) {
std::string s = "";
2020-05-10 14:25:42 +00:00
fmt::detail::utf16_to_utf8 u(L"");
EXPECT_EQ(s, u.str());
EXPECT_EQ(s.size(), u.size());
}
template <typename Converter, typename Char>
void check_utf_conversion_error(
const char* message,
fmt::basic_string_view<Char> str = fmt::basic_string_view<Char>(0, 1)) {
fmt::memory_buffer out;
2020-05-10 14:25:42 +00:00
fmt::detail::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
fmt::system_error error(0, "");
try {
(Converter)(str);
} catch (const fmt::system_error& e) {
error = e;
}
EXPECT_EQ(ERROR_INVALID_PARAMETER, error.error_code());
EXPECT_EQ(fmt::to_string(out), error.what());
}
TEST(UtilTest, UTF16ToUTF8Error) {
2020-05-10 14:25:42 +00:00
check_utf_conversion_error<fmt::detail::utf16_to_utf8, wchar_t>(
"cannot convert string from UTF-16 to UTF-8");
}
TEST(UtilTest, UTF16ToUTF8Convert) {
2020-05-10 14:25:42 +00:00
fmt::detail::utf16_to_utf8 u;
EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::wstring_view(0, 1)));
EXPECT_EQ(ERROR_INVALID_PARAMETER,
u.convert(fmt::wstring_view(L"foo", INT_MAX + 1u)));
}
TEST(UtilTest, FormatWindowsError) {
LPWSTR message = 0;
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
0, ERROR_FILE_EXISTS,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
reinterpret_cast<LPWSTR>(&message), 0, 0);
2020-05-10 14:25:42 +00:00
fmt::detail::utf16_to_utf8 utf8_message(message);
LocalFree(message);
fmt::memory_buffer actual_message;
2020-05-10 14:25:42 +00:00
fmt::detail::format_windows_error(actual_message, ERROR_FILE_EXISTS, "test");
EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
fmt::to_string(actual_message));
actual_message.resize(0);
2020-07-11 15:35:26 +00:00
auto max_size = fmt::detail::max_value<size_t>() / 2;
2020-05-10 14:25:42 +00:00
fmt::detail::format_windows_error(actual_message, ERROR_FILE_EXISTS,
fmt::string_view(nullptr, max_size));
EXPECT_EQ(fmt::format("error {}", ERROR_FILE_EXISTS),
fmt::to_string(actual_message));
}
TEST(UtilTest, FormatLongWindowsError) {
LPWSTR message = 0;
// this error code is not available on all Windows platforms and
// Windows SDKs, so do not fail the test if the error string cannot
// be retrieved.
const int provisioning_not_allowed =
0x80284013L /*TBS_E_PROVISIONING_NOT_ALLOWED*/;
if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
0, static_cast<DWORD>(provisioning_not_allowed),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
reinterpret_cast<LPWSTR>(&message), 0, 0) == 0) {
return;
}
2020-05-10 14:25:42 +00:00
fmt::detail::utf16_to_utf8 utf8_message(message);
LocalFree(message);
fmt::memory_buffer actual_message;
2020-05-10 14:25:42 +00:00
fmt::detail::format_windows_error(actual_message, provisioning_not_allowed,
"test");
EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
fmt::to_string(actual_message));
}
TEST(UtilTest, WindowsError) {
fmt::system_error error(0, "");
try {
throw fmt::windows_error(ERROR_FILE_EXISTS, "test {}", "error");
} catch (const fmt::system_error& e) {
error = e;
}
fmt::memory_buffer message;
2020-05-10 14:25:42 +00:00
fmt::detail::format_windows_error(message, ERROR_FILE_EXISTS, "test error");
EXPECT_EQ(to_string(message), error.what());
EXPECT_EQ(ERROR_FILE_EXISTS, error.error_code());
}
TEST(UtilTest, ReportWindowsError) {
fmt::memory_buffer out;
2020-05-10 14:25:42 +00:00
fmt::detail::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
out.push_back('\n');
EXPECT_WRITE(stderr,
fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
fmt::to_string(out));
}
#endif // _WIN32
2019-11-15 13:41:14 +00:00
#if FMT_USE_FCNTL
2018-05-19 17:32:53 +00:00
using fmt::file;
// Checks if the file is open by reading one character from it.
static bool isopen(int fd) {
char buffer;
return FMT_POSIX(read(fd, &buffer, 1)) == 1;
}
static bool isclosed(int fd) {
char buffer;
std::streamsize result = 0;
SUPPRESS_ASSERT(result = FMT_POSIX(read(fd, &buffer, 1)));
return result == -1 && errno == EBADF;
}
// Opens a file for reading.
static file open_file() {
2018-05-19 17:32:53 +00:00
file read_end, write_end;
file::pipe(read_end, write_end);
write_end.write(FILE_CONTENT, std::strlen(FILE_CONTENT));
write_end.close();
return read_end;
}
// Attempts to write a string to a file.
2019-01-13 02:27:38 +00:00
static void write(file& f, fmt::string_view s) {
2020-05-07 22:59:46 +00:00
size_t num_chars_left = s.size();
2019-01-13 02:27:38 +00:00
const char* ptr = s.data();
do {
2020-05-07 22:59:46 +00:00
size_t count = f.write(ptr, num_chars_left);
ptr += count;
// We can't write more than size_t bytes since num_chars_left
// has type size_t.
num_chars_left -= count;
} while (num_chars_left != 0);
}
TEST(BufferedFileTest, DefaultCtor) {
2018-05-19 15:57:31 +00:00
buffered_file f;
EXPECT_TRUE(f.get() == nullptr);
}
TEST(BufferedFileTest, MoveCtor) {
2018-05-19 15:57:31 +00:00
buffered_file bf = open_buffered_file();
2019-01-13 02:27:38 +00:00
FILE* fp = bf.get();
EXPECT_TRUE(fp != nullptr);
2018-05-19 15:57:31 +00:00
buffered_file bf2(std::move(bf));
EXPECT_EQ(fp, bf2.get());
EXPECT_TRUE(bf.get() == nullptr);
}
TEST(BufferedFileTest, MoveAssignment) {
2018-05-19 15:57:31 +00:00
buffered_file bf = open_buffered_file();
2019-01-13 02:27:38 +00:00
FILE* fp = bf.get();
EXPECT_TRUE(fp != nullptr);
2018-05-19 15:57:31 +00:00
buffered_file bf2;
bf2 = std::move(bf);
EXPECT_EQ(fp, bf2.get());
EXPECT_TRUE(bf.get() == nullptr);
}
TEST(BufferedFileTest, MoveAssignmentClosesFile) {
2018-05-19 15:57:31 +00:00
buffered_file bf = open_buffered_file();
buffered_file bf2 = open_buffered_file();
int old_fd = bf2.fileno();
bf2 = std::move(bf);
EXPECT_TRUE(isclosed(old_fd));
}
TEST(BufferedFileTest, MoveFromTemporaryInCtor) {
FILE* fp = nullptr;
2018-05-19 15:57:31 +00:00
buffered_file f(open_buffered_file(&fp));
EXPECT_EQ(fp, f.get());
}
TEST(BufferedFileTest, MoveFromTemporaryInAssignment) {
FILE* fp = nullptr;
2018-05-19 15:57:31 +00:00
buffered_file f;
f = open_buffered_file(&fp);
EXPECT_EQ(fp, f.get());
}
TEST(BufferedFileTest, MoveFromTemporaryInAssignmentClosesFile) {
2018-05-19 15:57:31 +00:00
buffered_file f = open_buffered_file();
int old_fd = f.fileno();
f = open_buffered_file();
EXPECT_TRUE(isclosed(old_fd));
}
TEST(BufferedFileTest, CloseFileInDtor) {
int fd = 0;
{
2018-05-19 15:57:31 +00:00
buffered_file f = open_buffered_file();
fd = f.fileno();
}
EXPECT_TRUE(isclosed(fd));
}
TEST(BufferedFileTest, CloseErrorInDtor) {
std::unique_ptr<buffered_file> f(new buffered_file(open_buffered_file()));
2020-05-07 22:59:46 +00:00
EXPECT_WRITE(
stderr,
{
// The close function must be called inside EXPECT_WRITE,
// otherwise the system may recycle closed file descriptor when
// redirecting the output in EXPECT_STDERR and the second close
// will break output redirection.
FMT_POSIX(close(f->fileno()));
SUPPRESS_ASSERT(f.reset(nullptr));
},
format_system_error(EBADF, "cannot close file") + "\n");
}
TEST(BufferedFileTest, Close) {
2018-05-19 15:57:31 +00:00
buffered_file f = open_buffered_file();
int fd = f.fileno();
f.close();
EXPECT_TRUE(f.get() == nullptr);
EXPECT_TRUE(isclosed(fd));
}
TEST(BufferedFileTest, CloseError) {
2018-05-19 15:57:31 +00:00
buffered_file f = open_buffered_file();
FMT_POSIX(close(f.fileno()));
EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
EXPECT_TRUE(f.get() == nullptr);
}
TEST(BufferedFileTest, Fileno) {
2018-05-19 15:57:31 +00:00
buffered_file f;
2019-12-21 21:10:45 +00:00
# ifndef __COVERITY__
// fileno on a null FILE pointer either crashes or returns an error.
// Disable Coverity because this is intentional.
2019-01-13 02:27:38 +00:00
EXPECT_DEATH_IF_SUPPORTED(
{
try {
f.fileno();
} catch (const fmt::system_error&) {
std::exit(1);
}
},
"");
2019-12-21 21:10:45 +00:00
# endif
f = open_buffered_file();
EXPECT_TRUE(f.fileno() != -1);
2018-05-19 17:32:53 +00:00
file copy = file::dup(f.fileno());
EXPECT_READ(copy, FILE_CONTENT);
}
2020-07-11 18:06:52 +00:00
TEST(OStreamTest, Print) {
fmt::ostream out = fmt::output_file("test-file");
out.print("The answer is {}.\n", 42);
out.close();
file in("test-file", file::RDONLY);
EXPECT_READ(in, "The answer is 42.\n");
}
2020-07-11 18:06:52 +00:00
TEST(OStreamTest, BufferBoundary) {
auto str = std::string(4096, 'x');
2020-07-11 18:06:52 +00:00
fmt::ostream out = fmt::output_file("test-file");
out.print("{}", str);
out.print("{}", str);
out.close();
file in("test-file", file::RDONLY);
EXPECT_READ(in, str + str);
}
2020-08-01 17:25:39 +00:00
TEST(OStreamTest, BufferSize) {
fmt::ostream out = fmt::output_file("test-file", fmt::buffer_size=1);
out.print("{}", "foo");
out.close();
file in("test-file", file::RDONLY);
EXPECT_READ(in, "foo");
}
TEST(FileTest, DefaultCtor) {
2018-05-19 17:32:53 +00:00
file f;
EXPECT_EQ(-1, f.descriptor());
}
TEST(FileTest, OpenBufferedFileInCtor) {
2019-01-13 02:27:38 +00:00
FILE* fp = safe_fopen("test-file", "w");
std::fputs(FILE_CONTENT, fp);
std::fclose(fp);
2018-05-19 17:32:53 +00:00
file f("test-file", file::RDONLY);
ASSERT_TRUE(isopen(f.descriptor()));
}
TEST(FileTest, OpenBufferedFileError) {
2019-01-13 02:27:38 +00:00
EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY), ENOENT,
"cannot open file nonexistent");
}
TEST(FileTest, MoveCtor) {
2018-05-19 17:32:53 +00:00
file f = open_file();
int fd = f.descriptor();
EXPECT_NE(-1, fd);
2018-05-19 17:32:53 +00:00
file f2(std::move(f));
EXPECT_EQ(fd, f2.descriptor());
EXPECT_EQ(-1, f.descriptor());
}
TEST(FileTest, MoveAssignment) {
2018-05-19 17:32:53 +00:00
file f = open_file();
int fd = f.descriptor();
EXPECT_NE(-1, fd);
2018-05-19 17:32:53 +00:00
file f2;
f2 = std::move(f);
EXPECT_EQ(fd, f2.descriptor());
EXPECT_EQ(-1, f.descriptor());
}
TEST(FileTest, MoveAssignmentClosesFile) {
2018-05-19 17:32:53 +00:00
file f = open_file();
file f2 = open_file();
int old_fd = f2.descriptor();
f2 = std::move(f);
EXPECT_TRUE(isclosed(old_fd));
}
2019-01-13 02:27:38 +00:00
static file OpenBufferedFile(int& fd) {
2018-05-19 17:32:53 +00:00
file f = open_file();
fd = f.descriptor();
2016-06-14 22:53:40 +00:00
return f;
}
TEST(FileTest, MoveFromTemporaryInCtor) {
2016-03-02 15:53:14 +00:00
int fd = 0xdead;
2018-05-19 17:32:53 +00:00
file f(OpenBufferedFile(fd));
EXPECT_EQ(fd, f.descriptor());
}
TEST(FileTest, MoveFromTemporaryInAssignment) {
2016-03-02 15:53:14 +00:00
int fd = 0xdead;
2018-05-19 17:32:53 +00:00
file f;
f = OpenBufferedFile(fd);
EXPECT_EQ(fd, f.descriptor());
}
TEST(FileTest, MoveFromTemporaryInAssignmentClosesFile) {
2016-03-02 15:53:14 +00:00
int fd = 0xdead;
2018-05-19 17:32:53 +00:00
file f = open_file();
int old_fd = f.descriptor();
f = OpenBufferedFile(fd);
EXPECT_TRUE(isclosed(old_fd));
}
TEST(FileTest, CloseFileInDtor) {
int fd = 0;
{
2018-05-19 17:32:53 +00:00
file f = open_file();
fd = f.descriptor();
}
EXPECT_TRUE(isclosed(fd));
}
TEST(FileTest, CloseErrorInDtor) {
std::unique_ptr<file> f(new file(open_file()));
2020-05-07 22:59:46 +00:00
EXPECT_WRITE(
stderr,
{
// The close function must be called inside EXPECT_WRITE,
// otherwise the system may recycle closed file descriptor when
// redirecting the output in EXPECT_STDERR and the second close
// will break output redirection.
FMT_POSIX(close(f->descriptor()));
SUPPRESS_ASSERT(f.reset(nullptr));
},
format_system_error(EBADF, "cannot close file") + "\n");
}
TEST(FileTest, Close) {
2018-05-19 17:32:53 +00:00
file f = open_file();
int fd = f.descriptor();
f.close();
EXPECT_EQ(-1, f.descriptor());
EXPECT_TRUE(isclosed(fd));
}
TEST(FileTest, CloseError) {
2018-05-19 17:32:53 +00:00
file f = open_file();
FMT_POSIX(close(f.descriptor()));
EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
EXPECT_EQ(-1, f.descriptor());
}
TEST(FileTest, Read) {
2018-05-19 17:32:53 +00:00
file f = open_file();
EXPECT_READ(f, FILE_CONTENT);
}
TEST(FileTest, ReadError) {
2018-05-19 17:32:53 +00:00
file f("test-file", file::WRONLY);
char buf;
2015-06-25 14:06:30 +00:00
// We intentionally read from a file opened in the write-only mode to
// cause error.
EXPECT_SYSTEM_ERROR(f.read(&buf, 1), EBADF, "cannot read from file");
}
TEST(FileTest, Write) {
2018-05-19 17:32:53 +00:00
file read_end, write_end;
file::pipe(read_end, write_end);
write(write_end, "test");
write_end.close();
EXPECT_READ(read_end, "test");
}
TEST(FileTest, WriteError) {
2018-05-19 17:32:53 +00:00
file f("test-file", file::RDONLY);
2015-06-25 14:06:30 +00:00
// We intentionally write to a file opened in the read-only mode to
// cause error.
EXPECT_SYSTEM_ERROR(f.write(" ", 1), EBADF, "cannot write to file");
}
TEST(FileTest, Dup) {
2018-05-19 17:32:53 +00:00
file f = open_file();
file copy = file::dup(f.descriptor());
EXPECT_NE(f.descriptor(), copy.descriptor());
EXPECT_EQ(FILE_CONTENT, read(copy, std::strlen(FILE_CONTENT)));
}
2019-12-21 21:10:45 +00:00
# ifndef __COVERITY__
TEST(FileTest, DupError) {
2015-10-21 15:30:10 +00:00
int value = -1;
2019-01-13 02:27:38 +00:00
EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value), EBADF,
"cannot duplicate file descriptor -1");
}
2019-12-21 21:10:45 +00:00
# endif
TEST(FileTest, Dup2) {
2018-05-19 17:32:53 +00:00
file f = open_file();
file copy = open_file();
f.dup2(copy.descriptor());
EXPECT_NE(f.descriptor(), copy.descriptor());
EXPECT_READ(copy, FILE_CONTENT);
}
TEST(FileTest, Dup2Error) {
2018-05-19 17:32:53 +00:00
file f = open_file();
2019-01-13 02:27:38 +00:00
EXPECT_SYSTEM_ERROR_NOASSERT(
f.dup2(-1), EBADF,
fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor()));
}
TEST(FileTest, Dup2NoExcept) {
2018-05-19 17:32:53 +00:00
file f = open_file();
file copy = open_file();
error_code ec;
f.dup2(copy.descriptor(), ec);
EXPECT_EQ(ec.get(), 0);
EXPECT_NE(f.descriptor(), copy.descriptor());
EXPECT_READ(copy, FILE_CONTENT);
}
TEST(FileTest, Dup2NoExceptError) {
2018-05-19 17:32:53 +00:00
file f = open_file();
error_code ec;
SUPPRESS_ASSERT(f.dup2(-1, ec));
EXPECT_EQ(EBADF, ec.get());
}
TEST(FileTest, Pipe) {
2018-05-19 17:32:53 +00:00
file read_end, write_end;
file::pipe(read_end, write_end);
EXPECT_NE(-1, read_end.descriptor());
EXPECT_NE(-1, write_end.descriptor());
write(write_end, "test");
EXPECT_READ(read_end, "test");
}
TEST(FileTest, Fdopen) {
2018-05-19 17:32:53 +00:00
file read_end, write_end;
file::pipe(read_end, write_end);
int read_fd = read_end.descriptor();
EXPECT_EQ(read_fd, FMT_POSIX(fileno(read_end.fdopen("r").get())));
}
2019-12-21 21:10:45 +00:00
# ifdef FMT_LOCALE
2016-01-30 00:29:46 +00:00
TEST(LocaleTest, Strtod) {
2020-04-01 16:30:28 +00:00
fmt::locale loc;
2016-01-30 00:29:46 +00:00
const char *start = "4.2", *ptr = start;
2020-04-01 16:30:28 +00:00
EXPECT_EQ(4.2, loc.strtod(ptr));
2016-01-30 00:29:46 +00:00
EXPECT_EQ(start + 3, ptr);
}
2019-12-21 21:10:45 +00:00
# endif
2020-05-07 22:59:46 +00:00
#endif // FMT_USE_FCNTL