From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/fmt/test/os-test.cc | 500 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 500 insertions(+) create mode 100644 src/fmt/test/os-test.cc (limited to 'src/fmt/test/os-test.cc') diff --git a/src/fmt/test/os-test.cc b/src/fmt/test/os-test.cc new file mode 100644 index 000000000..d1530e5a8 --- /dev/null +++ b/src/fmt/test/os-test.cc @@ -0,0 +1,500 @@ +// Formatting library for C++ - tests of the OS-specific functionality +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/os.h" + +#include // std::exit +#include +#include + +#include "gtest-extra.h" +#include "util.h" + +#ifdef fileno +# undef fileno +#endif + +using fmt::buffered_file; +using fmt::error_code; + +#ifdef _WIN32 + +# include + +TEST(UtilTest, UTF16ToUTF8) { + std::string s = "ёжик"; + 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 = ""; + fmt::detail::utf16_to_utf8 u(L""); + EXPECT_EQ(s, u.str()); + EXPECT_EQ(s.size(), u.size()); +} + +template +void check_utf_conversion_error( + const char* message, + fmt::basic_string_view str = fmt::basic_string_view(0, 1)) { + fmt::memory_buffer out; + 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) { + check_utf_conversion_error( + "cannot convert string from UTF-16 to UTF-8"); +} + +TEST(UtilTest, UTF16ToUTF8Convert) { + 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(&message), 0, 0); + fmt::detail::utf16_to_utf8 utf8_message(message); + LocalFree(message); + fmt::memory_buffer actual_message; + 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); + auto max_size = fmt::detail::max_value(); + fmt::detail::format_windows_error(actual_message, ERROR_FILE_EXISTS, + fmt::string_view(0, 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(provisioning_not_allowed), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + reinterpret_cast(&message), 0, 0) == 0) { + return; + } + fmt::detail::utf16_to_utf8 utf8_message(message); + LocalFree(message); + fmt::memory_buffer actual_message; + 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; + 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; + 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 + +#if FMT_USE_FCNTL + +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() { + 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. +static void write(file& f, fmt::string_view s) { + size_t num_chars_left = s.size(); + const char* ptr = s.data(); + do { + 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) { + buffered_file f; + EXPECT_TRUE(f.get() == nullptr); +} + +TEST(BufferedFileTest, MoveCtor) { + buffered_file bf = open_buffered_file(); + FILE* fp = bf.get(); + EXPECT_TRUE(fp != nullptr); + buffered_file bf2(std::move(bf)); + EXPECT_EQ(fp, bf2.get()); + EXPECT_TRUE(bf.get() == nullptr); +} + +TEST(BufferedFileTest, MoveAssignment) { + buffered_file bf = open_buffered_file(); + FILE* fp = bf.get(); + EXPECT_TRUE(fp != nullptr); + buffered_file bf2; + bf2 = std::move(bf); + EXPECT_EQ(fp, bf2.get()); + EXPECT_TRUE(bf.get() == nullptr); +} + +TEST(BufferedFileTest, MoveAssignmentClosesFile) { + 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; + buffered_file f(open_buffered_file(&fp)); + EXPECT_EQ(fp, f.get()); +} + +TEST(BufferedFileTest, MoveFromTemporaryInAssignment) { + FILE* fp = nullptr; + buffered_file f; + f = open_buffered_file(&fp); + EXPECT_EQ(fp, f.get()); +} + +TEST(BufferedFileTest, MoveFromTemporaryInAssignmentClosesFile) { + 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; + { + buffered_file f = open_buffered_file(); + fd = f.fileno(); + } + EXPECT_TRUE(isclosed(fd)); +} + +TEST(BufferedFileTest, CloseErrorInDtor) { + std::unique_ptr f(new buffered_file(open_buffered_file())); + 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) { + buffered_file f = open_buffered_file(); + int fd = f.fileno(); + f.close(); + EXPECT_TRUE(f.get() == nullptr); + EXPECT_TRUE(isclosed(fd)); +} + +TEST(BufferedFileTest, CloseError) { + 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) { + buffered_file f; +# ifndef __COVERITY__ + // fileno on a null FILE pointer either crashes or returns an error. + // Disable Coverity because this is intentional. + EXPECT_DEATH_IF_SUPPORTED( + { + try { + f.fileno(); + } catch (const fmt::system_error&) { + std::exit(1); + } + }, + ""); +# endif + f = open_buffered_file(); + EXPECT_TRUE(f.fileno() != -1); + file copy = file::dup(f.fileno()); + EXPECT_READ(copy, FILE_CONTENT); +} + +TEST(FileTest, DefaultCtor) { + file f; + EXPECT_EQ(-1, f.descriptor()); +} + +TEST(FileTest, OpenBufferedFileInCtor) { + FILE* fp = safe_fopen("test-file", "w"); + std::fputs(FILE_CONTENT, fp); + std::fclose(fp); + file f("test-file", file::RDONLY); + ASSERT_TRUE(isopen(f.descriptor())); +} + +TEST(FileTest, OpenBufferedFileError) { + EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY), ENOENT, + "cannot open file nonexistent"); +} + +TEST(FileTest, MoveCtor) { + file f = open_file(); + int fd = f.descriptor(); + EXPECT_NE(-1, fd); + file f2(std::move(f)); + EXPECT_EQ(fd, f2.descriptor()); + EXPECT_EQ(-1, f.descriptor()); +} + +TEST(FileTest, MoveAssignment) { + file f = open_file(); + int fd = f.descriptor(); + EXPECT_NE(-1, fd); + file f2; + f2 = std::move(f); + EXPECT_EQ(fd, f2.descriptor()); + EXPECT_EQ(-1, f.descriptor()); +} + +TEST(FileTest, MoveAssignmentClosesFile) { + file f = open_file(); + file f2 = open_file(); + int old_fd = f2.descriptor(); + f2 = std::move(f); + EXPECT_TRUE(isclosed(old_fd)); +} + +static file OpenBufferedFile(int& fd) { + file f = open_file(); + fd = f.descriptor(); + return f; +} + +TEST(FileTest, MoveFromTemporaryInCtor) { + int fd = 0xdead; + file f(OpenBufferedFile(fd)); + EXPECT_EQ(fd, f.descriptor()); +} + +TEST(FileTest, MoveFromTemporaryInAssignment) { + int fd = 0xdead; + file f; + f = OpenBufferedFile(fd); + EXPECT_EQ(fd, f.descriptor()); +} + +TEST(FileTest, MoveFromTemporaryInAssignmentClosesFile) { + int fd = 0xdead; + file f = open_file(); + int old_fd = f.descriptor(); + f = OpenBufferedFile(fd); + EXPECT_TRUE(isclosed(old_fd)); +} + +TEST(FileTest, CloseFileInDtor) { + int fd = 0; + { + file f = open_file(); + fd = f.descriptor(); + } + EXPECT_TRUE(isclosed(fd)); +} + +TEST(FileTest, CloseErrorInDtor) { + std::unique_ptr f(new file(open_file())); + 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) { + file f = open_file(); + int fd = f.descriptor(); + f.close(); + EXPECT_EQ(-1, f.descriptor()); + EXPECT_TRUE(isclosed(fd)); +} + +TEST(FileTest, CloseError) { + 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) { + file f = open_file(); + EXPECT_READ(f, FILE_CONTENT); +} + +TEST(FileTest, ReadError) { + file f("test-file", file::WRONLY); + char buf; + // 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) { + 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) { + file f("test-file", file::RDONLY); + // 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) { + 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))); +} + +# ifndef __COVERITY__ +TEST(FileTest, DupError) { + int value = -1; + EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value), EBADF, + "cannot duplicate file descriptor -1"); +} +# endif + +TEST(FileTest, Dup2) { + 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) { + file f = open_file(); + EXPECT_SYSTEM_ERROR_NOASSERT( + f.dup2(-1), EBADF, + fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor())); +} + +TEST(FileTest, Dup2NoExcept) { + 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) { + file f = open_file(); + error_code ec; + SUPPRESS_ASSERT(f.dup2(-1, ec)); + EXPECT_EQ(EBADF, ec.get()); +} + +TEST(FileTest, Pipe) { + 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) { + 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()))); +} + +# ifdef FMT_LOCALE +TEST(LocaleTest, Strtod) { + fmt::locale loc; + const char *start = "4.2", *ptr = start; + EXPECT_EQ(4.2, loc.strtod(ptr)); + EXPECT_EQ(start + 3, ptr); +} +# endif +#endif // FMT_USE_FCNTL -- cgit v1.2.3