399 lines
10 KiB
C++
399 lines
10 KiB
C++
|
/*
|
||
|
|
Tests of the C++ interface to POSIX functions
|
||
|
|
|
||
|
|
Copyright (c) 2015, 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 <cstdlib> // std::exit
|
||
|
|
#include <cstring>
|
||
|
|
|
||
|
|
#include "fmt/posix.h"
|
||
|
|
#include "gtest-extra.h"
|
||
|
|
#include "util.h"
|
||
|
|
|
||
|
|
#ifdef fileno
|
||
|
|
# undef fileno
|
||
|
|
#endif
|
||
|
|
|
||
|
|
using fmt::BufferedFile;
|
||
|
|
using fmt::ErrorCode;
|
||
|
|
using fmt::File;
|
||
|
|
|
||
|
|
using testing::internal::scoped_ptr;
|
||
|
|
|
||
|
|
// Checks if the file is open by reading one character from it.
|
||
|
|
bool isopen(int fd) {
|
||
|
|
char buffer;
|
||
|
|
return FMT_POSIX(read(fd, &buffer, 1)) == 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
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.
|
||
|
|
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.
|
||
|
|
void write(File &f, fmt::StringRef s) {
|
||
|
|
std::size_t num_chars_left = s.size();
|
||
|
|
const char *ptr = s.data();
|
||
|
|
do {
|
||
|
|
std::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 -= static_cast<std::size_t>(count);
|
||
|
|
} while (num_chars_left != 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, DefaultCtor) {
|
||
|
|
BufferedFile f;
|
||
|
|
EXPECT_TRUE(f.get() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, MoveCtor) {
|
||
|
|
BufferedFile bf = open_buffered_file();
|
||
|
|
FILE *fp = bf.get();
|
||
|
|
EXPECT_TRUE(fp != 0);
|
||
|
|
BufferedFile bf2(std::move(bf));
|
||
|
|
EXPECT_EQ(fp, bf2.get());
|
||
|
|
EXPECT_TRUE(bf.get() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, MoveAssignment) {
|
||
|
|
BufferedFile bf = open_buffered_file();
|
||
|
|
FILE *fp = bf.get();
|
||
|
|
EXPECT_TRUE(fp != 0);
|
||
|
|
BufferedFile bf2;
|
||
|
|
bf2 = std::move(bf);
|
||
|
|
EXPECT_EQ(fp, bf2.get());
|
||
|
|
EXPECT_TRUE(bf.get() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, MoveAssignmentClosesFile) {
|
||
|
|
BufferedFile bf = open_buffered_file();
|
||
|
|
BufferedFile bf2 = open_buffered_file();
|
||
|
|
int old_fd = bf2.fileno();
|
||
|
|
bf2 = std::move(bf);
|
||
|
|
EXPECT_TRUE(isclosed(old_fd));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, MoveFromTemporaryInCtor) {
|
||
|
|
FILE *fp = 0;
|
||
|
|
BufferedFile f(open_buffered_file(&fp));
|
||
|
|
EXPECT_EQ(fp, f.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, MoveFromTemporaryInAssignment) {
|
||
|
|
FILE *fp = 0;
|
||
|
|
BufferedFile f;
|
||
|
|
f = open_buffered_file(&fp);
|
||
|
|
EXPECT_EQ(fp, f.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, MoveFromTemporaryInAssignmentClosesFile) {
|
||
|
|
BufferedFile f = open_buffered_file();
|
||
|
|
int old_fd = f.fileno();
|
||
|
|
f = open_buffered_file();
|
||
|
|
EXPECT_TRUE(isclosed(old_fd));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, CloseFileInDtor) {
|
||
|
|
int fd = 0;
|
||
|
|
{
|
||
|
|
BufferedFile f = open_buffered_file();
|
||
|
|
fd = f.fileno();
|
||
|
|
}
|
||
|
|
EXPECT_TRUE(isclosed(fd));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, CloseErrorInDtor) {
|
||
|
|
scoped_ptr<BufferedFile> f(new BufferedFile(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());
|
||
|
|
}, format_system_error(EBADF, "cannot close file") + "\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, Close) {
|
||
|
|
BufferedFile f = open_buffered_file();
|
||
|
|
int fd = f.fileno();
|
||
|
|
f.close();
|
||
|
|
EXPECT_TRUE(f.get() == 0);
|
||
|
|
EXPECT_TRUE(isclosed(fd));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, CloseError) {
|
||
|
|
BufferedFile f = open_buffered_file();
|
||
|
|
FMT_POSIX(close(f.fileno()));
|
||
|
|
EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
|
||
|
|
EXPECT_TRUE(f.get() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(BufferedFileTest, Fileno) {
|
||
|
|
BufferedFile 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 (fmt::SystemError) {
|
||
|
|
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));
|
||
|
|
}
|
||
|
|
|
||
|
|
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) {
|
||
|
|
scoped_ptr<File> 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());
|
||
|
|
}, 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();
|
||
|
|
ErrorCode ec;
|
||
|
|
f.dup2(copy.descriptor(), ec);
|
||
|
|
EXPECT_EQ(0, ec.get());
|
||
|
|
EXPECT_NE(f.descriptor(), copy.descriptor());
|
||
|
|
EXPECT_READ(copy, FILE_CONTENT);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(FileTest, Dup2NoExceptError) {
|
||
|
|
File f = open_file();
|
||
|
|
ErrorCode 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())));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(FileTest, FdopenError) {
|
||
|
|
File f;
|
||
|
|
EXPECT_SYSTEM_ERROR_NOASSERT(
|
||
|
|
f.fdopen("r"), EBADF, "cannot associate stream with file descriptor");
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef FMT_LOCALE
|
||
|
|
TEST(LocaleTest, Strtod) {
|
||
|
|
fmt::Locale locale;
|
||
|
|
const char *start = "4.2", *ptr = start;
|
||
|
|
EXPECT_EQ(4.2, locale.strtod(ptr));
|
||
|
|
EXPECT_EQ(start + 3, ptr);
|
||
|
|
}
|
||
|
|
#endif
|