2014-05-03 16:48:54 +00:00
|
|
|
/*
|
|
|
|
Custom Google Test assertions.
|
|
|
|
|
|
|
|
Copyright (c) 2012-2014, Victor Zverovich
|
|
|
|
All rights reserved.
|
|
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
|
|
|
|
1. Redistributions of source code must retain the above copyright notice, this
|
|
|
|
list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
this list of conditions and the following disclaimer in the documentation
|
|
|
|
and/or other materials provided with the distribution.
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "gtest-extra.h"
|
|
|
|
|
|
|
|
#if FMT_USE_FILE_DESCRIPTORS
|
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
# include <unistd.h>
|
|
|
|
#else
|
|
|
|
# include <io.h>
|
|
|
|
|
|
|
|
# define O_CREAT _O_CREAT
|
|
|
|
# define O_TRUNC _O_TRUNC
|
|
|
|
# define S_IRUSR _S_IREAD
|
|
|
|
# define S_IWUSR _S_IWRITE
|
2014-05-03 18:03:04 +00:00
|
|
|
|
2014-05-03 16:48:54 +00:00
|
|
|
#endif // _WIN32
|
|
|
|
|
|
|
|
// Retries the expression while it evaluates to -1 and error equals to EINTR.
|
|
|
|
#define FMT_RETRY(result, expression) \
|
|
|
|
do { \
|
|
|
|
result = (expression); \
|
|
|
|
} while (result == -1 && errno == EINTR)
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
File::File(const char *path, int oflag) {
|
2014-05-03 16:48:54 +00:00
|
|
|
int mode = S_IRUSR | S_IWUSR;
|
|
|
|
#ifdef _WIN32
|
|
|
|
fd_ = -1;
|
2014-05-03 17:10:50 +00:00
|
|
|
_sopen_s(&fd_, path, oflag, _SH_DENYNO, mode);
|
2014-05-03 16:48:54 +00:00
|
|
|
#else
|
|
|
|
FMT_RETRY(fd_, open(path, oflag, mode));
|
|
|
|
#endif
|
|
|
|
if (fd_ == -1)
|
|
|
|
fmt::ThrowSystemError(errno, "cannot open file {}") << path;
|
|
|
|
}
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
void File::close() {
|
2014-05-03 16:48:54 +00:00
|
|
|
if (fd_ == -1)
|
|
|
|
return;
|
|
|
|
// Don't need to retry close in case of EINTR.
|
|
|
|
// See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
|
2014-05-03 17:10:50 +00:00
|
|
|
if (::FMT_POSIX(close(fd_)) != 0)
|
2014-05-03 16:48:54 +00:00
|
|
|
fmt::ReportSystemError(errno, "cannot close file");
|
|
|
|
}
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
std::streamsize File::read(void *buffer, std::size_t count) {
|
2014-05-03 18:26:46 +00:00
|
|
|
std::streamsize result = 0;
|
|
|
|
FMT_RETRY(result, ::read(fd_, buffer, count));
|
|
|
|
if (result == -1)
|
|
|
|
fmt::ThrowSystemError(errno, "cannot read from file");
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
std::streamsize File::write(const void *buffer, std::size_t count) {
|
2014-05-03 19:06:28 +00:00
|
|
|
std::streamsize result = 0;
|
|
|
|
FMT_RETRY(result, ::write(fd_, buffer, count));
|
|
|
|
if (result == -1)
|
|
|
|
fmt::ThrowSystemError(errno, "cannot write to file");
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
File File::dup(int fd) {
|
2014-05-03 16:48:54 +00:00
|
|
|
int new_fd = 0;
|
2014-05-03 17:10:50 +00:00
|
|
|
FMT_RETRY(new_fd, ::FMT_POSIX(dup(fd)));
|
2014-05-03 16:48:54 +00:00
|
|
|
if (new_fd == -1)
|
|
|
|
fmt::ThrowSystemError(errno, "cannot duplicate file descriptor {}") << fd;
|
2014-05-03 19:28:02 +00:00
|
|
|
return File(new_fd);
|
2014-05-03 16:48:54 +00:00
|
|
|
}
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
void File::dup2(int fd) {
|
2014-05-03 16:48:54 +00:00
|
|
|
int result = 0;
|
2014-05-03 17:10:50 +00:00
|
|
|
FMT_RETRY(result, ::FMT_POSIX(dup2(fd_, fd)));
|
2014-05-03 16:48:54 +00:00
|
|
|
if (result == -1) {
|
|
|
|
fmt::ThrowSystemError(errno,
|
|
|
|
"cannot duplicate file descriptor {} to {}") << fd_ << fd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
void File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT(true) {
|
2014-05-03 16:48:54 +00:00
|
|
|
int result = 0;
|
2014-05-03 17:10:50 +00:00
|
|
|
FMT_RETRY(result, ::FMT_POSIX(dup2(fd_, fd)));
|
2014-05-03 16:48:54 +00:00
|
|
|
if (result == -1)
|
|
|
|
ec = ErrorCode(errno);
|
|
|
|
}
|
|
|
|
|
2014-05-03 19:28:02 +00:00
|
|
|
void File::pipe(File &read_end, File &write_end) {
|
2014-05-03 16:48:54 +00:00
|
|
|
// Close the descriptors first to make sure that assignments don't throw
|
|
|
|
// and there are no leaks.
|
2014-05-03 19:28:02 +00:00
|
|
|
read_end.close();
|
|
|
|
write_end.close();
|
2014-05-03 16:48:54 +00:00
|
|
|
int fds[2] = {};
|
2014-05-03 17:25:46 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
// Make the default pipe capacity same as on Linux 2.6.11+.
|
|
|
|
enum { DEFAULT_CAPACITY = 65536 };
|
|
|
|
int result = _pipe(fds, DEFAULT_CAPACITY, _O_BINARY);
|
|
|
|
#else
|
2014-05-03 18:26:46 +00:00
|
|
|
// The pipe function doesn't return EINTR, so no need to retry.
|
2014-05-03 17:25:46 +00:00
|
|
|
int result = ::pipe(fds);
|
|
|
|
#endif
|
|
|
|
if (result != 0)
|
2014-05-03 16:48:54 +00:00
|
|
|
fmt::ThrowSystemError(errno, "cannot create pipe");
|
2014-05-03 17:25:46 +00:00
|
|
|
// The following assignments don't throw because read_fd and write_fd
|
|
|
|
// are closed.
|
2014-05-03 19:28:02 +00:00
|
|
|
read_end = File(fds[0]);
|
|
|
|
write_end = File(fds[1]);
|
2014-05-03 16:48:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
OutputRedirector::OutputRedirector(FILE *file) : file_(file) {
|
|
|
|
if (std::fflush(file) != 0)
|
|
|
|
fmt::ThrowSystemError(errno, "cannot flush stream");
|
|
|
|
int fd = fileno(file);
|
2014-05-03 19:28:02 +00:00
|
|
|
saved_ = File::dup(fd);
|
|
|
|
File write_end;
|
|
|
|
File::pipe(read_end_, write_end);
|
|
|
|
write_end.dup2(fd);
|
2014-05-03 16:48:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
OutputRedirector::~OutputRedirector() {
|
|
|
|
if (std::fflush(file_) != 0)
|
|
|
|
fmt::ReportSystemError(errno, "cannot flush stream");
|
|
|
|
ErrorCode ec;
|
2014-05-03 19:28:02 +00:00
|
|
|
saved_.dup2(fileno(file_), ec);
|
2014-05-03 16:48:54 +00:00
|
|
|
if (ec.get())
|
|
|
|
fmt::ReportSystemError(errno, "cannot restore output");
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string OutputRedirector::Read() {
|
|
|
|
// Restore output.
|
|
|
|
if (std::fflush(file_) != 0)
|
|
|
|
fmt::ThrowSystemError(errno, "cannot flush stream");
|
2014-05-03 19:28:02 +00:00
|
|
|
saved_.dup2(fileno(file_));
|
2014-05-03 16:48:54 +00:00
|
|
|
|
2014-05-03 18:26:46 +00:00
|
|
|
// Read everything from the pipe.
|
|
|
|
std::string content;
|
|
|
|
enum { BUFFER_SIZE = 4096 };
|
2014-05-03 16:48:54 +00:00
|
|
|
char buffer[BUFFER_SIZE];
|
2014-05-03 18:26:46 +00:00
|
|
|
std::streamsize count = 0;
|
|
|
|
do {
|
2014-05-03 19:28:02 +00:00
|
|
|
count = read_end_.read(buffer, BUFFER_SIZE);
|
2014-05-03 18:26:46 +00:00
|
|
|
content.append(buffer, count);
|
|
|
|
} while (count != 0);
|
|
|
|
return content;
|
2014-05-03 16:48:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: test EXPECT_STDOUT and EXPECT_STDERR
|
|
|
|
|
|
|
|
#endif // FMT_USE_FILE_DESCRIPTORS
|