Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 2 of 2.

1 files changed, 458 insertions, 458 deletions

diff --git a/contrib/libs/fmt/test/os-test.cc b/contrib/libs/fmt/test/os-test.cc
index 4e17c5d522..359b5ff8ce 100644
--- a/contrib/libs/fmt/test/os-test.cc
+++ b/contrib/libs/fmt/test/os-test.cc
@@ -1,243 +1,243 @@
-// 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. 
- 
+// 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 <cstdlib>  // std::exit 
-#include <cstring> 
-#include <memory> 
- 
-#include "gtest-extra.h" 
-#include "util.h" 
- 
-#ifdef fileno 
-#  undef fileno 
-#endif 
- 
-using fmt::buffered_file; 
-using fmt::error_code; 
- 
-#ifdef _WIN32 
- 
-#  include <windows.h> 
- 
-TEST(UtilTest, UTF16ToUTF8) { 
-  std::string s = "ёжик"; 
+#include <cstdlib>  // std::exit
+#include <cstring>
+#include <memory>
+
+#include "gtest-extra.h"
+#include "util.h"
+
+#ifdef fileno
+#  undef fileno
+#endif
+
+using fmt::buffered_file;
+using fmt::error_code;
+
+#ifdef _WIN32
+
+#  include <windows.h>
+
+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 = ""; 
+  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 <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; 
+  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;
   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) { 
+  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<fmt::detail::utf16_to_utf8, wchar_t>(
-      "cannot convert string from UTF-16 to UTF-8"); 
-} 
- 
-TEST(UtilTest, UTF16ToUTF8Convert) { 
+      "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<LPWSTR>(&message), 0, 0); 
+  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);
   fmt::detail::utf16_to_utf8 utf8_message(message);
-  LocalFree(message); 
-  fmt::memory_buffer actual_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); 
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+            fmt::to_string(actual_message));
+  actual_message.resize(0);
   auto max_size = fmt::detail::max_value<size_t>() / 2;
   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; 
-  } 
+  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;
+  }
   fmt::detail::utf16_to_utf8 utf8_message(message);
-  LocalFree(message); 
-  fmt::memory_buffer actual_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; 
+  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; 
+  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) { 
+  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 { 
+  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<buffered_file> f(new buffered_file(open_buffered_file())); 
+    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<buffered_file> f(new buffered_file(open_buffered_file()));
   EXPECT_WRITE(
       stderr,
       {
@@ -249,44 +249,44 @@ TEST(BufferedFileTest, CloseErrorInDtor) {
         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(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(OStreamTest, Move) {
   fmt::ostream out = fmt::output_file("test-file");
   fmt::ostream moved(std::move(out));
@@ -319,89 +319,89 @@ TEST(OStreamTest, BufferSize) {
   EXPECT_READ(in, "foo");
 }
 
-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<file> f(new file(open_file())); 
+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<file> f(new file(open_file()));
   EXPECT_WRITE(
       stderr,
       {
@@ -413,120 +413,120 @@ TEST(FileTest, CloseErrorInDtor) {
         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 
+}
+
+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