diff --git a/phosphor-power-sequencer/docs/config_file/rail.md b/phosphor-power-sequencer/docs/config_file/rail.md
index d369405..982c6a6 100644
--- a/phosphor-power-sequencer/docs/config_file/rail.md
+++ b/phosphor-power-sequencer/docs/config_file/rail.md
@@ -22,7 +22,7 @@
 ### Notes
 
 - The "page" property is required if the "check_status_vout" or
-  "compare_voltage_to_limits" property is specified.
+  "compare_voltage_to_limits" property is true.
 
 ## Examples
 
diff --git a/phosphor-power-sequencer/src/config_file_parser.cpp b/phosphor-power-sequencer/src/config_file_parser.cpp
new file mode 100644
index 0000000..db055d1
--- /dev/null
+++ b/phosphor-power-sequencer/src/config_file_parser.cpp
@@ -0,0 +1,173 @@
+/**
+ * Copyright © 2024 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 "config_file_parser.hpp"
+
+#include "config_file_parser_error.hpp"
+
+#include <exception>
+#include <fstream>
+#include <optional>
+
+using json = nlohmann::json;
+
+namespace phosphor::power::sequencer::config_file_parser
+{
+
+std::vector<std::unique_ptr<Rail>> parse(const std::filesystem::path& pathName)
+{
+    try
+    {
+        // Use standard JSON parser to create tree of JSON elements
+        std::ifstream file{pathName};
+        json rootElement = json::parse(file);
+
+        // Parse tree of JSON elements and return corresponding C++ objects
+        return internal::parseRoot(rootElement);
+    }
+    catch (const std::exception& e)
+    {
+        throw ConfigFileParserError{pathName, e.what()};
+    }
+}
+
+namespace internal
+{
+
+GPIO parseGPIO(const json& element)
+{
+    verifyIsObject(element);
+    unsigned int propertyCount{0};
+
+    // Required line property
+    const json& lineElement = getRequiredProperty(element, "line");
+    unsigned int line = parseUnsignedInteger(lineElement);
+    ++propertyCount;
+
+    // Optional active_low property
+    bool activeLow{false};
+    auto activeLowIt = element.find("active_low");
+    if (activeLowIt != element.end())
+    {
+        activeLow = parseBoolean(*activeLowIt);
+        ++propertyCount;
+    }
+
+    // Verify no invalid properties exist
+    verifyPropertyCount(element, propertyCount);
+
+    return GPIO(line, activeLow);
+}
+
+std::unique_ptr<Rail> parseRail(const json& element)
+{
+    verifyIsObject(element);
+    unsigned int propertyCount{0};
+
+    // Required name property
+    const json& nameElement = getRequiredProperty(element, "name");
+    std::string name = parseString(nameElement);
+    ++propertyCount;
+
+    // Optional presence property
+    std::optional<std::string> presence{};
+    auto presenceIt = element.find("presence");
+    if (presenceIt != element.end())
+    {
+        presence = parseString(*presenceIt);
+        ++propertyCount;
+    }
+
+    // Optional page property
+    std::optional<uint8_t> page{};
+    auto pageIt = element.find("page");
+    if (pageIt != element.end())
+    {
+        page = parseUint8(*pageIt);
+        ++propertyCount;
+    }
+
+    // Optional check_status_vout property
+    bool checkStatusVout{false};
+    auto checkStatusVoutIt = element.find("check_status_vout");
+    if (checkStatusVoutIt != element.end())
+    {
+        checkStatusVout = parseBoolean(*checkStatusVoutIt);
+        ++propertyCount;
+    }
+
+    // Optional compare_voltage_to_limits property
+    bool compareVoltageToLimits{false};
+    auto compareVoltageToLimitsIt = element.find("compare_voltage_to_limits");
+    if (compareVoltageToLimitsIt != element.end())
+    {
+        compareVoltageToLimits = parseBoolean(*compareVoltageToLimitsIt);
+        ++propertyCount;
+    }
+
+    // Optional gpio property
+    std::optional<GPIO> gpio{};
+    auto gpioIt = element.find("gpio");
+    if (gpioIt != element.end())
+    {
+        gpio = parseGPIO(*gpioIt);
+        ++propertyCount;
+    }
+
+    // If check_status_vout or compare_voltage_to_limits property is true,
+    // the page property is required; verify page was specified
+    if ((checkStatusVout || compareVoltageToLimits) && !page.has_value())
+    {
+        throw std::invalid_argument{"Required property missing: page"};
+    }
+
+    // Verify no invalid properties exist
+    verifyPropertyCount(element, propertyCount);
+
+    return std::make_unique<Rail>(name, presence, page, checkStatusVout,
+                                  compareVoltageToLimits, gpio);
+}
+
+std::vector<std::unique_ptr<Rail>> parseRailArray(const json& element)
+{
+    verifyIsArray(element);
+    std::vector<std::unique_ptr<Rail>> rails;
+    for (auto& railElement : element)
+    {
+        rails.emplace_back(parseRail(railElement));
+    }
+    return rails;
+}
+
+std::vector<std::unique_ptr<Rail>> parseRoot(const json& element)
+{
+    verifyIsObject(element);
+    unsigned int propertyCount{0};
+
+    // Required rails property
+    const json& railsElement = getRequiredProperty(element, "rails");
+    std::vector<std::unique_ptr<Rail>> rails = parseRailArray(railsElement);
+    ++propertyCount;
+
+    // Verify no invalid properties exist
+    verifyPropertyCount(element, propertyCount);
+
+    return rails;
+}
+
+} // namespace internal
+
+} // namespace phosphor::power::sequencer::config_file_parser
diff --git a/phosphor-power-sequencer/src/config_file_parser.hpp b/phosphor-power-sequencer/src/config_file_parser.hpp
new file mode 100644
index 0000000..3764b7c
--- /dev/null
+++ b/phosphor-power-sequencer/src/config_file_parser.hpp
@@ -0,0 +1,265 @@
+/**
+ * Copyright © 2024 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.
+ */
+#pragma once
+
+#include "rail.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <cstdint>
+#include <filesystem>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace phosphor::power::sequencer::config_file_parser
+{
+
+/**
+ * Parses the specified JSON configuration file.
+ *
+ * Returns the corresponding C++ Rail objects.
+ *
+ * Throws a ConfigFileParserError if an error occurs.
+ *
+ * @param pathName configuration file path name
+ * @return vector of Rail objects
+ */
+std::vector<std::unique_ptr<Rail>> parse(const std::filesystem::path& pathName);
+
+/*
+ * Internal implementation details for parse()
+ */
+namespace internal
+{
+
+/**
+ * Returns the specified property of the specified JSON element.
+ *
+ * Throws an invalid_argument exception if the property does not exist.
+ *
+ * @param element JSON element
+ * @param property property name
+ */
+#pragma GCC diagnostic push
+#if __GNUC__ == 13
+#pragma GCC diagnostic ignored "-Wdangling-reference"
+#endif
+inline const nlohmann::json& getRequiredProperty(const nlohmann::json& element,
+                                                 const std::string& property)
+{
+    auto it = element.find(property);
+    if (it == element.end())
+    {
+        throw std::invalid_argument{"Required property missing: " + property};
+    }
+    return *it;
+}
+#pragma GCC diagnostic pop
+
+/**
+ * Parses a JSON element containing a boolean.
+ *
+ * Returns the corresponding C++ boolean value.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return boolean value
+ */
+inline bool parseBoolean(const nlohmann::json& element)
+{
+    // Verify element contains a boolean
+    if (!element.is_boolean())
+    {
+        throw std::invalid_argument{"Element is not a boolean"};
+    }
+    return element.get<bool>();
+}
+
+/**
+ * Parses a JSON element containing a GPIO.
+ *
+ * Returns the corresponding C++ GPIO object.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return GPIO object
+ */
+GPIO parseGPIO(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing a rail.
+ *
+ * Returns the corresponding C++ Rail object.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return Rail object
+ */
+std::unique_ptr<Rail> parseRail(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing an array of rails.
+ *
+ * Returns the corresponding C++ Rail objects.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return vector of Rail objects
+ */
+std::vector<std::unique_ptr<Rail>>
+    parseRailArray(const nlohmann::json& element);
+
+/**
+ * Parses the JSON root element of the entire configuration file.
+ *
+ * Returns the corresponding C++ Rail objects.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return vector of Rail objects
+ */
+std::vector<std::unique_ptr<Rail>> parseRoot(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing a string.
+ *
+ * Returns the corresponding C++ string.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @param isEmptyValid indicates whether an empty string value is valid
+ * @return string value
+ */
+inline std::string parseString(const nlohmann::json& element,
+                               bool isEmptyValid = false)
+{
+    if (!element.is_string())
+    {
+        throw std::invalid_argument{"Element is not a string"};
+    }
+    std::string value = element.get<std::string>();
+    if (value.empty() && !isEmptyValid)
+    {
+        throw std::invalid_argument{"Element contains an empty string"};
+    }
+    return value;
+}
+
+/**
+ * Parses a JSON element containing an 8-bit unsigned integer.
+ *
+ * Returns the corresponding C++ uint8_t value.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return uint8_t value
+ */
+inline uint8_t parseUint8(const nlohmann::json& element)
+{
+    // Verify element contains an integer
+    if (!element.is_number_integer())
+    {
+        throw std::invalid_argument{"Element is not an integer"};
+    }
+    int value = element.get<int>();
+    if ((value < 0) || (value > UINT8_MAX))
+    {
+        throw std::invalid_argument{"Element is not an 8-bit unsigned integer"};
+    }
+    return static_cast<uint8_t>(value);
+}
+
+/**
+ * Parses a JSON element containing an unsigned integer.
+ *
+ * Returns the corresponding C++ unsigned int value.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return unsigned int value
+ */
+inline unsigned int parseUnsignedInteger(const nlohmann::json& element)
+{
+    // Verify element contains an unsigned integer
+    if (!element.is_number_unsigned())
+    {
+        throw std::invalid_argument{"Element is not an unsigned integer"};
+    }
+    return element.get<unsigned int>();
+}
+
+/**
+ * Verifies that the specified JSON element is a JSON array.
+ *
+ * Throws an invalid_argument exception if the element is not an array.
+ *
+ * @param element JSON element
+ */
+inline void verifyIsArray(const nlohmann::json& element)
+{
+    if (!element.is_array())
+    {
+        throw std::invalid_argument{"Element is not an array"};
+    }
+}
+
+/**
+ * Verifies that the specified JSON element is a JSON object.
+ *
+ * Throws an invalid_argument exception if the element is not an object.
+ *
+ * @param element JSON element
+ */
+inline void verifyIsObject(const nlohmann::json& element)
+{
+    if (!element.is_object())
+    {
+        throw std::invalid_argument{"Element is not an object"};
+    }
+}
+
+/**
+ * Verifies that the specified JSON element contains the expected number of
+ * properties.
+ *
+ * Throws an invalid_argument exception if the element contains a different
+ * number of properties.  This indicates the element contains an invalid
+ * property.
+ *
+ * @param element JSON element
+ * @param expectedCount expected number of properties in element
+ */
+inline void verifyPropertyCount(const nlohmann::json& element,
+                                unsigned int expectedCount)
+{
+    if (element.size() != expectedCount)
+    {
+        throw std::invalid_argument{"Element contains an invalid property"};
+    }
+}
+
+} // namespace internal
+
+} // namespace phosphor::power::sequencer::config_file_parser
diff --git a/phosphor-power-sequencer/src/config_file_parser_error.hpp b/phosphor-power-sequencer/src/config_file_parser_error.hpp
new file mode 100644
index 0000000..4c77952
--- /dev/null
+++ b/phosphor-power-sequencer/src/config_file_parser_error.hpp
@@ -0,0 +1,85 @@
+/**
+ * Copyright © 2024 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.
+ */
+#pragma once
+
+#include <exception>
+#include <filesystem>
+#include <string>
+
+namespace phosphor::power::sequencer
+{
+
+/**
+ * @class ConfigFileParserError
+ *
+ * An error that occurred while parsing a JSON configuration file.
+ */
+class ConfigFileParserError : public std::exception
+{
+  public:
+    // Specify which compiler-generated methods we want
+    ConfigFileParserError() = delete;
+    ConfigFileParserError(const ConfigFileParserError&) = default;
+    ConfigFileParserError(ConfigFileParserError&&) = default;
+    ConfigFileParserError& operator=(const ConfigFileParserError&) = default;
+    ConfigFileParserError& operator=(ConfigFileParserError&&) = default;
+    virtual ~ConfigFileParserError() = default;
+
+    /**
+     * Constructor.
+     *
+     * @param pathName Configuration file path name
+     * @param error Error message
+     */
+    explicit ConfigFileParserError(const std::filesystem::path& pathName,
+                                   const std::string& error) :
+        pathName{pathName},
+        error{"ConfigFileParserError: " + pathName.string() + ": " + error}
+    {}
+
+    /**
+     * Returns the configuration file path name.
+     *
+     * @return path name
+     */
+    const std::filesystem::path& getPathName()
+    {
+        return pathName;
+    }
+
+    /**
+     * Returns the description of this error.
+     *
+     * @return error description
+     */
+    const char* what() const noexcept override
+    {
+        return error.c_str();
+    }
+
+  private:
+    /**
+     * Configuration file path name.
+     */
+    const std::filesystem::path pathName;
+
+    /**
+     * Error message.
+     */
+    const std::string error{};
+};
+
+} // namespace phosphor::power::sequencer
diff --git a/phosphor-power-sequencer/src/meson.build b/phosphor-power-sequencer/src/meson.build
index de691c9..faab116 100644
--- a/phosphor-power-sequencer/src/meson.build
+++ b/phosphor-power-sequencer/src/meson.build
@@ -3,6 +3,18 @@
     '../..'
 )
 
+phosphor_power_sequencer_library = static_library(
+    'phosphor-power-sequencer',
+    'config_file_parser.cpp',
+    implicit_include_directories: false,
+    dependencies: [
+        nlohmann_json_dep
+    ],
+    include_directories: [
+        phosphor_power_sequencer_include_directories
+    ]
+)
+
 phosphor_power_sequencer = executable(
     'phosphor-power-control',
     'power_control_main.cpp',
diff --git a/phosphor-power-sequencer/test/config_file_parser_error_tests.cpp b/phosphor-power-sequencer/test/config_file_parser_error_tests.cpp
new file mode 100644
index 0000000..9af389a
--- /dev/null
+++ b/phosphor-power-sequencer/test/config_file_parser_error_tests.cpp
@@ -0,0 +1,53 @@
+/**
+ * Copyright © 2024 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 "config_file_parser_error.hpp"
+
+#include <filesystem>
+
+#include <gtest/gtest.h>
+
+using namespace phosphor::power::sequencer;
+
+TEST(ConfigFileParserErrorTests, Constructor)
+{
+    std::filesystem::path pathName{
+        "/usr/share/phosphor-power-sequencer/foo.json"};
+    ConfigFileParserError error{pathName, "Required property missing"};
+    EXPECT_EQ(error.getPathName(), pathName);
+    EXPECT_STREQ(
+        error.what(),
+        "ConfigFileParserError: /usr/share/phosphor-power-sequencer/foo.json: "
+        "Required property missing");
+}
+
+TEST(ConfigFileParserErrorTests, GetPathName)
+{
+    std::filesystem::path pathName{
+        "/usr/share/phosphor-power-sequencer/bar.json"};
+    ConfigFileParserError error{pathName, "Required property missing"};
+    EXPECT_EQ(error.getPathName(), pathName);
+}
+
+TEST(ConfigFileParserErrorTests, What)
+{
+    std::filesystem::path pathName{
+        "/usr/share/phosphor-power-sequencer/bar.json"};
+    ConfigFileParserError error{pathName, "Required property missing"};
+    EXPECT_STREQ(
+        error.what(),
+        "ConfigFileParserError: /usr/share/phosphor-power-sequencer/bar.json: "
+        "Required property missing");
+}
diff --git a/phosphor-power-sequencer/test/config_file_parser_tests.cpp b/phosphor-power-sequencer/test/config_file_parser_tests.cpp
new file mode 100644
index 0000000..bfc9680
--- /dev/null
+++ b/phosphor-power-sequencer/test/config_file_parser_tests.cpp
@@ -0,0 +1,877 @@
+/**
+ * Copyright © 2024 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 "config_file_parser.hpp"
+#include "config_file_parser_error.hpp"
+#include "rail.hpp"
+#include "temporary_file.hpp"
+
+#include <sys/stat.h> // for chmod()
+
+#include <nlohmann/json.hpp>
+
+#include <cstdint>
+#include <exception>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using namespace phosphor::power::sequencer;
+using namespace phosphor::power::sequencer::config_file_parser;
+using namespace phosphor::power::sequencer::config_file_parser::internal;
+using json = nlohmann::json;
+using TemporaryFile = phosphor::power::util::TemporaryFile;
+
+void writeConfigFile(const std::filesystem::path& pathName,
+                     const std::string& contents)
+{
+    std::ofstream file{pathName};
+    file << contents;
+}
+
+void writeConfigFile(const std::filesystem::path& pathName,
+                     const json& contents)
+{
+    std::ofstream file{pathName};
+    file << contents;
+}
+
+TEST(ConfigFileParserTests, Parse)
+{
+    // Test where works
+    {
+        const json configFileContents = R"(
+            {
+                "rails": [
+                    {
+                        "name": "VDD_CPU0",
+                        "page": 11,
+                        "check_status_vout": true
+                    },
+                    {
+                        "name": "VCS_CPU1",
+                        "presence": "/xyz/openbmc_project/inventory/system/chassis/motherboard/cpu1",
+                        "gpio": { "line": 60 }
+                    }
+                ]
+            }
+        )"_json;
+
+        TemporaryFile configFile;
+        std::filesystem::path pathName{configFile.getPath()};
+        writeConfigFile(pathName, configFileContents);
+
+        std::vector<std::unique_ptr<Rail>> rails = parse(pathName);
+
+        EXPECT_EQ(rails.size(), 2);
+        EXPECT_EQ(rails[0]->getName(), "VDD_CPU0");
+        EXPECT_EQ(rails[1]->getName(), "VCS_CPU1");
+    }
+
+    // Test where fails: File does not exist
+    {
+        std::filesystem::path pathName{"/tmp/non_existent_file"};
+        EXPECT_THROW(parse(pathName), ConfigFileParserError);
+    }
+
+    // Test where fails: File is not readable
+    {
+        const json configFileContents = R"(
+            {
+                "rails": [
+                    {
+                        "name": "VDD_CPU0"
+                    }
+                ]
+            }
+        )"_json;
+
+        TemporaryFile configFile;
+        std::filesystem::path pathName{configFile.getPath()};
+        writeConfigFile(pathName, configFileContents);
+
+        chmod(pathName.c_str(), 0222);
+        EXPECT_THROW(parse(pathName), ConfigFileParserError);
+    }
+
+    // Test where fails: File is not valid JSON
+    {
+        const std::string configFileContents = "] foo [";
+
+        TemporaryFile configFile;
+        std::filesystem::path pathName{configFile.getPath()};
+        writeConfigFile(pathName, configFileContents);
+
+        EXPECT_THROW(parse(pathName), ConfigFileParserError);
+    }
+
+    // Test where fails: JSON does not conform to config file format
+    {
+        const json configFileContents = R"( [ "foo", "bar" ] )"_json;
+
+        TemporaryFile configFile;
+        std::filesystem::path pathName{configFile.getPath()};
+        writeConfigFile(pathName, configFileContents);
+
+        EXPECT_THROW(parse(pathName), ConfigFileParserError);
+    }
+}
+
+TEST(ConfigFileParserTests, GetRequiredProperty)
+{
+    // Test where property exists
+    {
+        const json element = R"( { "name": "VDD_CPU0" } )"_json;
+        const json& propertyElement = getRequiredProperty(element, "name");
+        EXPECT_EQ(propertyElement.get<std::string>(), "VDD_CPU0");
+    }
+
+    // Test where property does not exist
+    try
+    {
+        const json element = R"( { "foo": 23 } )"_json;
+        getRequiredProperty(element, "name");
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Required property missing: name");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseBoolean)
+{
+    // Test where works: true
+    {
+        const json element = R"( true )"_json;
+        bool value = parseBoolean(element);
+        EXPECT_EQ(value, true);
+    }
+
+    // Test where works: false
+    {
+        const json element = R"( false )"_json;
+        bool value = parseBoolean(element);
+        EXPECT_EQ(value, false);
+    }
+
+    // Test where fails: Element is not a boolean
+    try
+    {
+        const json element = R"( 1 )"_json;
+        parseBoolean(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not a boolean");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseGPIO)
+{
+    // Test where works: Only required properties specified
+    {
+        const json element = R"(
+            {
+                "line": 60
+            }
+        )"_json;
+        GPIO gpio = parseGPIO(element);
+        EXPECT_EQ(gpio.line, 60);
+        EXPECT_FALSE(gpio.activeLow);
+    }
+
+    // Test where works: All properties specified
+    {
+        const json element = R"(
+            {
+                "line": 131,
+                "active_low": true
+            }
+        )"_json;
+        GPIO gpio = parseGPIO(element);
+        EXPECT_EQ(gpio.line, 131);
+        EXPECT_TRUE(gpio.activeLow);
+    }
+
+    // Test where fails: Element is not an object
+    try
+    {
+        const json element = R"( [ "vdda", "vddb" ] )"_json;
+        parseGPIO(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an object");
+    }
+
+    // Test where fails: Required line property not specified
+    try
+    {
+        const json element = R"(
+            {
+                "active_low": true
+            }
+        )"_json;
+        parseGPIO(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Required property missing: line");
+    }
+
+    // Test where fails: line value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "line": -131,
+                "active_low": true
+            }
+        )"_json;
+        parseGPIO(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an unsigned integer");
+    }
+
+    // Test where fails: active_low value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "line": 131,
+                "active_low": "true"
+            }
+        )"_json;
+        parseGPIO(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not a boolean");
+    }
+
+    // Test where fails: Invalid property specified
+    try
+    {
+        const json element = R"(
+            {
+                "line": 131,
+                "foo": "bar"
+            }
+        )"_json;
+        parseGPIO(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element contains an invalid property");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseRail)
+{
+    // Test where works: Only required properties specified
+    {
+        const json element = R"(
+            {
+                "name": "VDD_CPU0"
+            }
+        )"_json;
+        std::unique_ptr<Rail> rail = parseRail(element);
+        EXPECT_EQ(rail->getName(), "VDD_CPU0");
+        EXPECT_FALSE(rail->getPresence().has_value());
+        EXPECT_FALSE(rail->getPage().has_value());
+        EXPECT_FALSE(rail->getCheckStatusVout());
+        EXPECT_FALSE(rail->getCompareVoltageToLimits());
+        EXPECT_FALSE(rail->getGPIO().has_value());
+    }
+
+    // Test where works: All properties specified
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "presence": "/xyz/openbmc_project/inventory/system/chassis/motherboard/cpu1",
+                "page": 11,
+                "check_status_vout": true,
+                "compare_voltage_to_limits": true,
+                "gpio": { "line": 60, "active_low": true }
+            }
+        )"_json;
+        std::unique_ptr<Rail> rail = parseRail(element);
+        EXPECT_EQ(rail->getName(), "VCS_CPU1");
+        EXPECT_TRUE(rail->getPresence().has_value());
+        EXPECT_EQ(
+            rail->getPresence().value(),
+            "/xyz/openbmc_project/inventory/system/chassis/motherboard/cpu1");
+        EXPECT_TRUE(rail->getPage().has_value());
+        EXPECT_EQ(rail->getPage().value(), 11);
+        EXPECT_TRUE(rail->getCheckStatusVout());
+        EXPECT_TRUE(rail->getCompareVoltageToLimits());
+        EXPECT_TRUE(rail->getGPIO().has_value());
+        EXPECT_EQ(rail->getGPIO().value().line, 60);
+        EXPECT_TRUE(rail->getGPIO().value().activeLow);
+    }
+
+    // Test where fails: Element is not an object
+    try
+    {
+        const json element = R"( [ "vdda", "vddb" ] )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an object");
+    }
+
+    // Test where fails: Required name property not specified
+    try
+    {
+        const json element = R"(
+            {
+                "page": 11
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Required property missing: name");
+    }
+
+    // Test where fails: name value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "name": 31,
+                "page": 11
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not a string");
+    }
+
+    // Test where fails: presence value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "presence": false
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not a string");
+    }
+
+    // Test where fails: page value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "page": 256
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an 8-bit unsigned integer");
+    }
+
+    // Test where fails: check_status_vout value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "check_status_vout": "false"
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not a boolean");
+    }
+
+    // Test where fails: compare_voltage_to_limits value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "compare_voltage_to_limits": 23
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not a boolean");
+    }
+
+    // Test where fails: gpio value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "gpio": 131
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an object");
+    }
+
+    // Test where fails: check_status_vout is true and page not specified
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "check_status_vout": true
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Required property missing: page");
+    }
+
+    // Test where fails: compare_voltage_to_limits is true and page not
+    // specified
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "compare_voltage_to_limits": true
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Required property missing: page");
+    }
+
+    // Test where fails: Invalid property specified
+    try
+    {
+        const json element = R"(
+            {
+                "name": "VCS_CPU1",
+                "foo": "bar"
+            }
+        )"_json;
+        parseRail(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element contains an invalid property");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseRailArray)
+{
+    // Test where works: Array is empty
+    {
+        const json element = R"(
+            [
+            ]
+        )"_json;
+        std::vector<std::unique_ptr<Rail>> rails = parseRailArray(element);
+        EXPECT_EQ(rails.size(), 0);
+    }
+
+    // Test where works: Array is not empty
+    {
+        const json element = R"(
+            [
+                { "name": "VDD_CPU0" },
+                { "name": "VCS_CPU1" }
+            ]
+        )"_json;
+        std::vector<std::unique_ptr<Rail>> rails = parseRailArray(element);
+        EXPECT_EQ(rails.size(), 2);
+        EXPECT_EQ(rails[0]->getName(), "VDD_CPU0");
+        EXPECT_EQ(rails[1]->getName(), "VCS_CPU1");
+    }
+
+    // Test where fails: Element is not an array
+    try
+    {
+        const json element = R"(
+            {
+                "foo": "bar"
+            }
+        )"_json;
+        parseRailArray(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an array");
+    }
+
+    // Test where fails: Element within array is invalid
+    try
+    {
+        const json element = R"(
+            [
+                { "name": "VDD_CPU0" },
+                23
+            ]
+        )"_json;
+        parseRailArray(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an object");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseRoot)
+{
+    // Test where works
+    {
+        const json element = R"(
+            {
+                "rails": [
+                    {
+                        "name": "VDD_CPU0",
+                        "page": 11,
+                        "check_status_vout": true
+                    },
+                    {
+                        "name": "VCS_CPU1",
+                        "presence": "/xyz/openbmc_project/inventory/system/chassis/motherboard/cpu1",
+                        "gpio": { "line": 60 }
+                    }
+                ]
+            }
+        )"_json;
+        std::vector<std::unique_ptr<Rail>> rails = parseRoot(element);
+        EXPECT_EQ(rails.size(), 2);
+        EXPECT_EQ(rails[0]->getName(), "VDD_CPU0");
+        EXPECT_EQ(rails[1]->getName(), "VCS_CPU1");
+    }
+
+    // Test where fails: Element is not an object
+    try
+    {
+        const json element = R"( [ "VDD_CPU0", "VCS_CPU1" ] )"_json;
+        parseRoot(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an object");
+    }
+
+    // Test where fails: Required rails property not specified
+    try
+    {
+        const json element = R"(
+            {
+            }
+        )"_json;
+        parseRoot(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Required property missing: rails");
+    }
+
+    // Test where fails: rails value is invalid
+    try
+    {
+        const json element = R"(
+            {
+                "rails": 31
+            }
+        )"_json;
+        parseRoot(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an array");
+    }
+
+    // Test where fails: Invalid property specified
+    try
+    {
+        const json element = R"(
+            {
+                "rails": [
+                    {
+                        "name": "VDD_CPU0",
+                        "page": 11,
+                        "check_status_vout": true
+                    }
+                ],
+                "foo": true
+            }
+        )"_json;
+        parseRoot(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element contains an invalid property");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseString)
+{
+    // Test where works: Empty string
+    {
+        const json element = "";
+        std::string value = parseString(element, true);
+        EXPECT_EQ(value, "");
+    }
+
+    // Test where works: Non-empty string
+    {
+        const json element = "vdd_cpu1";
+        std::string value = parseString(element, false);
+        EXPECT_EQ(value, "vdd_cpu1");
+    }
+
+    // Test where fails: Element is not a string
+    try
+    {
+        const json element = R"( { "foo": "bar" } )"_json;
+        parseString(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not a string");
+    }
+
+    // Test where fails: Empty string
+    try
+    {
+        const json element = "";
+        parseString(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element contains an empty string");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseUint8)
+{
+    // Test where works: 0
+    {
+        const json element = R"( 0 )"_json;
+        uint8_t value = parseUint8(element);
+        EXPECT_EQ(value, 0);
+    }
+
+    // Test where works: UINT8_MAX
+    {
+        const json element = R"( 255 )"_json;
+        uint8_t value = parseUint8(element);
+        EXPECT_EQ(value, 255);
+    }
+
+    // Test where fails: Element is not an integer
+    try
+    {
+        const json element = R"( 1.03 )"_json;
+        parseUint8(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an integer");
+    }
+
+    // Test where fails: Value < 0
+    try
+    {
+        const json element = R"( -1 )"_json;
+        parseUint8(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an 8-bit unsigned integer");
+    }
+
+    // Test where fails: Value > UINT8_MAX
+    try
+    {
+        const json element = R"( 256 )"_json;
+        parseUint8(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an 8-bit unsigned integer");
+    }
+}
+
+TEST(ConfigFileParserTests, ParseUnsignedInteger)
+{
+    // Test where works: 1
+    {
+        const json element = R"( 1 )"_json;
+        unsigned int value = parseUnsignedInteger(element);
+        EXPECT_EQ(value, 1);
+    }
+
+    // Test where fails: Element is not an integer
+    try
+    {
+        const json element = R"( 1.5 )"_json;
+        parseUnsignedInteger(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an unsigned integer");
+    }
+
+    // Test where fails: Value < 0
+    try
+    {
+        const json element = R"( -1 )"_json;
+        parseUnsignedInteger(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an unsigned integer");
+    }
+}
+
+TEST(ConfigFileParserTests, VerifyIsArray)
+{
+    // Test where element is an array
+    {
+        const json element = R"( [ "foo", "bar" ] )"_json;
+        verifyIsArray(element);
+    }
+
+    // Test where element is not an array
+    try
+    {
+        const json element = R"( { "foo": "bar" } )"_json;
+        verifyIsArray(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an array");
+    }
+}
+
+TEST(ConfigFileParserTests, VerifyIsObject)
+{
+    // Test where element is an object
+    {
+        const json element = R"( { "foo": "bar" } )"_json;
+        verifyIsObject(element);
+    }
+
+    // Test where element is not an object
+    try
+    {
+        const json element = R"( [ "foo", "bar" ] )"_json;
+        verifyIsObject(element);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element is not an object");
+    }
+}
+
+TEST(ConfigFileParserTests, VerifyPropertyCount)
+{
+    // Test where element has expected number of properties
+    {
+        const json element = R"(
+            {
+                "line": 131,
+                "active_low": true
+            }
+        )"_json;
+        verifyPropertyCount(element, 2);
+    }
+
+    // Test where element has unexpected number of properties
+    try
+    {
+        const json element = R"(
+            {
+                "line": 131,
+                "active_low": true,
+                "foo": 1.3
+            }
+        )"_json;
+        verifyPropertyCount(element, 2);
+        ADD_FAILURE() << "Should not have reached this line.";
+    }
+    catch (const std::invalid_argument& e)
+    {
+        EXPECT_STREQ(e.what(), "Element contains an invalid property");
+    }
+}
diff --git a/phosphor-power-sequencer/test/meson.build b/phosphor-power-sequencer/test/meson.build
index ab03041..4f6b167 100644
--- a/phosphor-power-sequencer/test/meson.build
+++ b/phosphor-power-sequencer/test/meson.build
@@ -1,5 +1,7 @@
 test('phosphor-power-sequencer-tests',
      executable('phosphor-power-sequencer-tests',
+                'config_file_parser_error_tests.cpp',
+                'config_file_parser_tests.cpp',
                 'rail_tests.cpp',
                 dependencies: [
                     gtest,
@@ -7,10 +9,15 @@
                 ],
                 link_args: dynamic_linker,
                 build_rpath: get_option('oe-sdk').allowed() ? rpath : '',
+                link_with: [
+                    phosphor_power_sequencer_library,
+                    libpower
+                ],
                 implicit_include_directories: false,
                 include_directories: [
                     '.',
-                    '../src'
+                    '../src',
+                    '../..'
                 ]
      )
 )