diff --git a/.gitignore b/.gitignore
index cbcc721..22d5abf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -42,4 +42,4 @@
 
 # Output binaries
 /example/pulse
-/test/gpio
+/test/internal_fd
diff --git a/configure.ac b/configure.ac
index aef8ae7..633816e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -131,6 +131,9 @@
 # Code coverage
 AX_CODE_COVERAGE
 AM_EXTRA_RECURSIVE_TARGETS([check-code-coverage])
+AS_IF([test "x$CODE_COVERAGE_ENABLED" = "xyes"], [
+    AX_APPEND_COMPILE_FLAGS([-DHAVE_GCOV], [CODE_COVERAGE_CPPFLAGS])
+])
 
 # Append -Werror after doing autoconf compiler checks
 # Otherwise some perfectly valid checks can fail and cause our
diff --git a/test/Makefile.am b/test/Makefile.am
index ccd4075..a338bfe 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -6,3 +6,8 @@
 
 check_PROGRAMS =
 TESTS = $(check_PROGRAMS)
+
+check_PROGRAMS += internal_fd
+internal_fd_SOURCES = internal/fd.cpp
+internal_fd_CPPFLAGS = $(gtest_cppflags)
+internal_fd_LDADD = $(gtest_ldadd)
diff --git a/test/internal/fd.cpp b/test/internal/fd.cpp
new file mode 100644
index 0000000..852c5c6
--- /dev/null
+++ b/test/internal/fd.cpp
@@ -0,0 +1,273 @@
+#include <cerrno>
+#include <cstring>
+#include <fcntl.h>
+#include <gmock/gmock.h>
+#include <gpioplus/internal/fd.hpp>
+#include <gpioplus/test/sys.hpp>
+#include <gtest/gtest.h>
+#include <memory>
+#include <signal.h>
+#include <sys/prctl.h>
+#include <system_error>
+#include <type_traits>
+#include <utility>
+
+#ifdef HAVE_GCOV
+// Needed for the abrt test
+extern "C" void __gcov_flush(void);
+#endif
+
+namespace gpioplus
+{
+namespace internal
+{
+namespace
+{
+
+using testing::Assign;
+using testing::DoAll;
+using testing::Return;
+
+class FdTest : public testing::Test
+{
+  protected:
+    const int expected_fd = 1234;
+    const int expected_fd2 = 2345;
+    const int expected_fd3 = 3456;
+    testing::StrictMock<test::SysMock> mock;
+    testing::StrictMock<test::SysMock> mock2;
+};
+
+TEST_F(FdTest, ConstructSimple)
+{
+    Fd fd(expected_fd, std::false_type(), &mock);
+    EXPECT_EQ(expected_fd, *fd);
+    EXPECT_EQ(&mock, fd.getSys());
+
+    EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+}
+
+TEST_F(FdTest, ConstructSimplBadFd)
+{
+    Fd fd(-1, std::false_type(), &mock);
+    EXPECT_EQ(-1, *fd);
+}
+
+TEST_F(FdTest, ConstructDup)
+{
+    EXPECT_CALL(mock, dup(expected_fd)).WillOnce(Return(expected_fd2));
+    Fd fd(expected_fd, &mock);
+    EXPECT_EQ(expected_fd2, *fd);
+    EXPECT_EQ(&mock, fd.getSys());
+
+    EXPECT_CALL(mock, close(expected_fd2)).WillOnce(Return(0));
+}
+
+TEST_F(FdTest, ConstructDupFail)
+{
+    EXPECT_CALL(mock, dup(expected_fd))
+        .WillOnce(DoAll(Assign(&errno, EINVAL), Return(-1)));
+    EXPECT_THROW(Fd(expected_fd, &mock), std::system_error);
+}
+
+void abrt_handler(int signum)
+{
+    if (signum == SIGABRT)
+    {
+#ifdef HAVE_GCOV
+        __gcov_flush();
+#endif
+    }
+}
+
+TEST_F(FdTest, CloseFails)
+{
+    EXPECT_DEATH(
+        {
+            struct sigaction act;
+            act.sa_handler = abrt_handler;
+            sigemptyset(&act.sa_mask);
+            act.sa_flags = 0;
+            ASSERT_EQ(0, sigaction(SIGABRT, &act, nullptr));
+            ASSERT_EQ(0, prctl(PR_SET_DUMPABLE, 0, 0, 0, 0));
+            EXPECT_CALL(mock, close(expected_fd))
+                .WillOnce(DoAll(Assign(&errno, EINVAL), Return(-1)));
+            Fd(expected_fd, std::false_type(), &mock);
+        },
+        "");
+}
+
+TEST_F(FdTest, ConstructSuccess)
+{
+    const char* path = "/no-such-path/gpio";
+    const int flags = O_RDWR;
+    EXPECT_CALL(mock, open(path, flags)).WillOnce(Return(expected_fd));
+    Fd fd(path, flags, &mock);
+    EXPECT_EQ(expected_fd, *fd);
+    EXPECT_EQ(&mock, fd.getSys());
+
+    EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+}
+
+TEST_F(FdTest, ConstructError)
+{
+    const char* path = "/no-such-path/gpio";
+    const int flags = O_RDWR;
+    EXPECT_CALL(mock, open(path, flags))
+        .WillOnce(DoAll(Assign(&errno, EBUSY), Return(-1)));
+    EXPECT_THROW(Fd(path, flags, &mock), std::system_error);
+}
+
+TEST_F(FdTest, ConstructCopy)
+{
+    Fd fd(expected_fd, std::false_type(), &mock);
+    {
+        EXPECT_CALL(mock, dup(expected_fd)).WillOnce(Return(expected_fd2));
+        Fd fd2(fd);
+        EXPECT_EQ(expected_fd2, *fd2);
+        EXPECT_EQ(expected_fd, *fd);
+
+        EXPECT_CALL(mock, close(expected_fd2)).WillOnce(Return(0));
+    }
+
+    EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+}
+
+TEST_F(FdTest, OperatorCopySame)
+{
+    Fd fd(expected_fd, std::false_type(), &mock);
+    fd = fd;
+    EXPECT_EQ(expected_fd, *fd);
+
+    EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+}
+
+TEST_F(FdTest, OperatorCopy)
+{
+    Fd fd(expected_fd, std::false_type(), &mock);
+    {
+        Fd fd2(expected_fd2, std::false_type(), &mock2);
+        EXPECT_CALL(mock2, close(expected_fd2)).WillOnce(Return(0));
+        EXPECT_CALL(mock, dup(expected_fd)).WillOnce(Return(expected_fd3));
+        fd2 = fd;
+        EXPECT_EQ(expected_fd3, *fd2);
+        EXPECT_EQ(&mock, fd2.getSys());
+        EXPECT_EQ(expected_fd, *fd);
+        EXPECT_EQ(&mock, fd.getSys());
+
+        EXPECT_CALL(mock, close(expected_fd3)).WillOnce(Return(0));
+    }
+
+    EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+}
+
+TEST_F(FdTest, ConstructMove)
+{
+    Fd fd(expected_fd, std::false_type(), &mock);
+    {
+        Fd fd2(std::move(fd));
+        EXPECT_EQ(expected_fd, *fd2);
+        EXPECT_EQ(-1, *fd);
+
+        EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+    }
+}
+
+TEST_F(FdTest, OperatorMoveSame)
+{
+    Fd fd(expected_fd, std::false_type(), &mock);
+    fd = std::move(fd);
+    EXPECT_EQ(expected_fd, *fd);
+
+    EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+}
+
+TEST_F(FdTest, OperatorMove)
+{
+    Fd fd(expected_fd, std::false_type(), &mock);
+    {
+        Fd fd2(expected_fd2, std::false_type(), &mock2);
+        EXPECT_CALL(mock2, close(expected_fd2)).WillOnce(Return(0));
+        fd2 = std::move(fd);
+        EXPECT_EQ(expected_fd, *fd2);
+        EXPECT_EQ(&mock, fd2.getSys());
+        EXPECT_EQ(-1, *fd);
+        EXPECT_EQ(&mock, fd.getSys());
+
+        EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+    }
+}
+
+class FdMethodTest : public FdTest
+{
+  protected:
+    const int flags_blocking = O_SYNC | O_NOATIME;
+    const int flags_noblocking = O_NONBLOCK | flags_blocking;
+    std::unique_ptr<Fd> fd;
+
+    void SetUp()
+    {
+        fd = std::make_unique<Fd>(expected_fd, std::false_type(), &mock);
+    }
+
+    void TearDown()
+    {
+        EXPECT_CALL(mock, close(expected_fd)).WillOnce(Return(0));
+        fd.reset();
+    }
+};
+
+TEST_F(FdMethodTest, SetBlockingOnBlocking)
+{
+    EXPECT_CALL(mock, fcntl_getfl(expected_fd))
+        .WillOnce(Return(flags_blocking));
+    EXPECT_CALL(mock, fcntl_setfl(expected_fd, flags_blocking))
+        .WillOnce(Return(0));
+    fd->setBlocking(true);
+}
+
+TEST_F(FdMethodTest, SetBlockingOnNonBlocking)
+{
+    EXPECT_CALL(mock, fcntl_getfl(expected_fd))
+        .WillOnce(Return(flags_noblocking));
+    EXPECT_CALL(mock, fcntl_setfl(expected_fd, flags_blocking))
+        .WillOnce(Return(0));
+    fd->setBlocking(true);
+}
+
+TEST_F(FdMethodTest, SetNonBlockingOnBlocking)
+{
+    EXPECT_CALL(mock, fcntl_getfl(expected_fd))
+        .WillOnce(Return(flags_blocking));
+    EXPECT_CALL(mock, fcntl_setfl(expected_fd, flags_noblocking))
+        .WillOnce(Return(0));
+    fd->setBlocking(false);
+}
+
+TEST_F(FdMethodTest, SetNonBlockingOnNonBlocking)
+{
+    EXPECT_CALL(mock, fcntl_getfl(expected_fd))
+        .WillOnce(Return(flags_noblocking));
+    EXPECT_CALL(mock, fcntl_setfl(expected_fd, flags_noblocking))
+        .WillOnce(Return(0));
+    fd->setBlocking(false);
+}
+
+TEST_F(FdMethodTest, GetFlagsFail)
+{
+    EXPECT_CALL(mock, fcntl_getfl(expected_fd))
+        .WillOnce(DoAll(Assign(&errno, EINVAL), Return(-1)));
+    EXPECT_THROW(fd->setBlocking(true), std::system_error);
+}
+
+TEST_F(FdMethodTest, SetFlagsFail)
+{
+    EXPECT_CALL(mock, fcntl_getfl(expected_fd)).WillOnce(Return(0));
+    EXPECT_CALL(mock, fcntl_setfl(expected_fd, 0))
+        .WillOnce(DoAll(Assign(&errno, EINVAL), Return(-1)));
+    EXPECT_THROW(fd->setBlocking(true), std::system_error);
+}
+
+} // namespace
+} // namespace internal
+} // namespace gpioplus