diff --git a/test/file_descriptor_tests.cpp b/test/file_descriptor_tests.cpp
new file mode 100644
index 0000000..4273086
--- /dev/null
+++ b/test/file_descriptor_tests.cpp
@@ -0,0 +1,270 @@
+/**
+ * Copyright © 2020 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "file_descriptor.hpp"
+
+#include <errno.h>     // for errno
+#include <fcntl.h>     // for open() and fcntl()
+#include <sys/stat.h>  // for open()
+#include <sys/types.h> // for open()
+#include <unistd.h>    // for fcntl()
+
+#include <utility>
+
+#include <gtest/gtest.h>
+
+using namespace phosphor::power::util;
+
+/**
+ * Returns whether the specified file descriptor is valid/open.
+ *
+ * @param[in] fd - File descriptor
+ * @return true if descriptor is valid/open, false otherwise
+ */
+bool isValid(int fd)
+{
+    return (fcntl(fd, F_GETFL) != -1) || (errno != EBADF);
+}
+
+/**
+ * Creates an open file descriptor.
+ *
+ * Verifies the file descriptor is valid.
+ *
+ * @return file descriptor
+ */
+int createOpenFileDescriptor()
+{
+    int fd = open("/etc/hosts", O_RDONLY);
+    EXPECT_NE(fd, -1);
+    EXPECT_TRUE(isValid(fd));
+    return fd;
+}
+
+TEST(FileDescriptorTests, DefaultConstructor)
+{
+    FileDescriptor descriptor;
+    EXPECT_EQ(descriptor(), -1);
+    EXPECT_FALSE(descriptor.operator bool());
+}
+
+TEST(FileDescriptorTests, IntConstructor)
+{
+    int fd = createOpenFileDescriptor();
+    FileDescriptor descriptor{fd};
+    EXPECT_EQ(descriptor(), fd);
+    EXPECT_TRUE(descriptor.operator bool());
+    EXPECT_TRUE(isValid(fd));
+}
+
+TEST(FileDescriptorTests, MoveConstructor)
+{
+    // Create first FileDescriptor object with open file descriptor
+    int fd = createOpenFileDescriptor();
+    FileDescriptor descriptor1{fd};
+    EXPECT_EQ(descriptor1(), fd);
+    EXPECT_TRUE(isValid(fd));
+
+    // Create second FileDescriptor object, moving in the contents of the first
+    FileDescriptor descriptor2{std::move(descriptor1)};
+
+    // Verify descriptor has been moved out of first object
+    EXPECT_EQ(descriptor1(), -1);
+
+    // Verify descriptor has been moved into second object
+    EXPECT_EQ(descriptor2(), fd);
+
+    // Verify descriptor is still valid/open
+    EXPECT_TRUE(isValid(fd));
+}
+
+TEST(FileDescriptorTests, MoveAssignmentOperator)
+{
+    // Test where move is valid
+    {
+        // Create first FileDescriptor object with open file descriptor
+        int fd1 = createOpenFileDescriptor();
+        FileDescriptor descriptor1{fd1};
+        EXPECT_EQ(descriptor1(), fd1);
+        EXPECT_TRUE(isValid(fd1));
+
+        // Create second FileDescriptor object with open file descriptor
+        int fd2 = createOpenFileDescriptor();
+        FileDescriptor descriptor2{fd2};
+        EXPECT_EQ(descriptor2(), fd2);
+        EXPECT_TRUE(isValid(fd2));
+
+        // Move second FileDescriptor object into the first
+        descriptor1 = std::move(descriptor2);
+
+        // Verify second file descriptor has been moved into first object
+        EXPECT_EQ(descriptor1(), fd2);
+
+        // Verify second file descriptor has been moved out of second object
+        EXPECT_EQ(descriptor2(), -1);
+
+        // Verify first file descriptor has been closed and is no longer valid
+        EXPECT_FALSE(isValid(fd1));
+
+        // Verify second file descriptor is still valid
+        EXPECT_TRUE(isValid(fd2));
+    }
+
+    // Test where move is invalid: Attempt to move object into itself
+    {
+        // Create FileDescriptor object with open file descriptor
+        int fd = createOpenFileDescriptor();
+        FileDescriptor descriptor{fd};
+        EXPECT_EQ(descriptor(), fd);
+        EXPECT_TRUE(isValid(fd));
+
+        // Try to move object into itself
+        descriptor = std::move(descriptor);
+
+        // Verify object still contains file descriptor
+        EXPECT_EQ(descriptor(), fd);
+        EXPECT_TRUE(isValid(fd));
+    }
+}
+
+TEST(FileDescriptorTests, Destructor)
+{
+    // Test where file descriptor was never set
+    {
+        FileDescriptor descriptor;
+        EXPECT_EQ(descriptor(), -1);
+    }
+
+    // Test where file descriptor was already closed
+    {
+        // Create FileDescriptor object with open file descriptor.  Close the
+        // descriptor explicitly.
+        int fd = createOpenFileDescriptor();
+        {
+            FileDescriptor descriptor{fd};
+            EXPECT_EQ(descriptor(), fd);
+            EXPECT_TRUE(isValid(fd));
+
+            EXPECT_EQ(descriptor.close(), 0);
+            EXPECT_EQ(descriptor(), -1);
+            EXPECT_FALSE(isValid(fd));
+        }
+        EXPECT_FALSE(isValid(fd));
+    }
+
+    // Test where file descriptor needs to be closed
+    {
+        // Create FileDescriptor object with open file descriptor.  Destructor
+        // will close descriptor.
+        int fd = createOpenFileDescriptor();
+        {
+            FileDescriptor descriptor{fd};
+            EXPECT_EQ(descriptor(), fd);
+            EXPECT_TRUE(isValid(fd));
+        }
+        EXPECT_FALSE(isValid(fd));
+    }
+}
+
+TEST(FileDescriptorTests, FunctionCallOperator)
+{
+    // Test where FileDescriptor object does not contain a valid file descriptor
+    FileDescriptor descriptor{};
+    EXPECT_EQ(descriptor(), -1);
+
+    // Test where FileDescriptor object contains a valid file descriptor
+    int fd = createOpenFileDescriptor();
+    descriptor.set(fd);
+    EXPECT_EQ(descriptor(), fd);
+}
+
+TEST(FileDescriptorTests, OperatorBool)
+{
+    // Test where FileDescriptor object does not contain a valid file descriptor
+    FileDescriptor descriptor{};
+    EXPECT_FALSE(descriptor.operator bool());
+    if (descriptor)
+    {
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+
+    // Test where FileDescriptor object contains a valid file descriptor
+    int fd = createOpenFileDescriptor();
+    descriptor.set(fd);
+    EXPECT_TRUE(descriptor.operator bool());
+    if (!descriptor)
+    {
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+
+    // Test where file descriptor has been closed
+    EXPECT_EQ(descriptor.close(), 0);
+    EXPECT_FALSE(descriptor.operator bool());
+    if (descriptor)
+    {
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+}
+
+TEST(FileDescriptorTests, Close)
+{
+    // Test where object contains an open file descriptor
+    int fd = createOpenFileDescriptor();
+    FileDescriptor descriptor{fd};
+    EXPECT_EQ(descriptor(), fd);
+    EXPECT_TRUE(isValid(fd));
+    EXPECT_EQ(descriptor.close(), 0);
+    EXPECT_EQ(descriptor(), -1);
+    EXPECT_FALSE(isValid(fd));
+
+    // Test where object does not contain an open file descriptor
+    EXPECT_EQ(descriptor(), -1);
+    EXPECT_EQ(descriptor.close(), 0);
+    EXPECT_EQ(descriptor(), -1);
+
+    // Test where close() fails due to invalid file descriptor
+    descriptor.set(999999);
+    EXPECT_EQ(descriptor.close(), -1);
+    EXPECT_EQ(errno, EBADF);
+    EXPECT_EQ(descriptor(), -1);
+}
+
+TEST(FileDescriptorTests, Set)
+{
+    // Test where object does not contain an open file descriptor
+    FileDescriptor descriptor{};
+    EXPECT_EQ(descriptor(), -1);
+    int fd1 = createOpenFileDescriptor();
+    descriptor.set(fd1);
+    EXPECT_EQ(descriptor(), fd1);
+    EXPECT_TRUE(isValid(fd1));
+
+    // Test where object contains an open file descriptor.  Should close
+    // previous descriptor.
+    EXPECT_EQ(descriptor(), fd1);
+    EXPECT_TRUE(isValid(fd1));
+    int fd2 = createOpenFileDescriptor();
+    descriptor.set(fd2);
+    EXPECT_EQ(descriptor(), fd2);
+    EXPECT_FALSE(isValid(fd1));
+    EXPECT_TRUE(isValid(fd2));
+
+    // Test where -1 is specified.  Should close previous descriptor.
+    EXPECT_EQ(descriptor(), fd2);
+    EXPECT_TRUE(isValid(fd2));
+    descriptor.set(-1);
+    EXPECT_EQ(descriptor(), -1);
+    EXPECT_FALSE(isValid(fd2));
+}
diff --git a/test/meson.build b/test/meson.build
index 48233c5..ca71994 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -12,3 +12,17 @@
         include_directories: '..',
     )
 )
+
+test(
+    'file_descriptor_tests',
+    executable(
+        'file_descriptor_tests', 'file_descriptor_tests.cpp',
+        dependencies: [
+            gtest,
+        ],
+        link_args: dynamic_linker,
+        build_rpath: get_option('oe-sdk').enabled() ? rpath : '',
+        implicit_include_directories: false,
+        include_directories: '..',
+    )
+)