diff --git a/Makefile.am b/Makefile.am
index 2de74ce..26c1980 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,7 +3,6 @@
 noinst_HEADERS = watchdog.hpp
 
 phosphor_watchdog_SOURCES =  \
-                argument.cpp \
                 watchdog.cpp \
                 mainapp.cpp
 
diff --git a/argument.cpp b/argument.cpp
deleted file mode 100644
index fa0d4bc..0000000
--- a/argument.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/**
- * Copyright © 2016 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 "argument.hpp"
-
-#include <cassert>
-#include <iostream>
-
-namespace phosphor
-{
-namespace watchdog
-{
-
-using namespace std::string_literals;
-
-const std::vector<std::string> emptyArg;
-const std::string ArgumentParser::trueString = "true"s;
-
-const char* ArgumentParser::optionStr = "p:s:t:a:f:i:ech";
-// clang-format off
-const option ArgumentParser::options[] =
-{
-    { "path",                    required_argument,  nullptr,   'p' },
-    { "service",                 required_argument,  nullptr,   's' },
-    { "target",                  required_argument,  nullptr,   't' },
-    { "action_target",           required_argument,  nullptr,   'a' },
-    { "fallback_action",         required_argument,  nullptr,   'f' },
-    { "fallback_interval",       required_argument,  nullptr,   'i' },
-    { "fallback_always",         no_argument,        nullptr,   'e' },
-    { "continue",                no_argument,        nullptr,   'c' },
-    { "help",                    no_argument,        nullptr,   'h' },
-    { 0, 0, 0, 0},
-};
-// clang-format on
-
-ArgumentParser::ArgumentParser(int argc, char* const argv[])
-{
-    int option;
-    int opt_idx = 0;
-
-    // We have to reset optind because getopt_long keeps global state
-    // and uses optind to track what argv index it needs to process next.
-    // Since this object may be instantiated more than once or test suites may
-    // already process instructions, optind may not be initialized to point to
-    // the beginning of our argv.
-    optind = 0;
-    while (-1 !=
-           (option = getopt_long(argc, argv, optionStr, options, &opt_idx)))
-    {
-        if (option == '?' || option == 'h')
-        {
-            usage(argv);
-            exit(-1);
-        }
-
-        auto i = &options[opt_idx];
-        while (i->val && i->val != option)
-        {
-            ++i;
-        }
-
-        if (i->val)
-        {
-            arguments[i->name].push_back(optarg ? optarg : trueString);
-        }
-
-        opt_idx = 0;
-    }
-}
-
-const std::vector<std::string>& ArgumentParser::
-    operator[](const std::string& opt)
-{
-    auto i = arguments.find(opt);
-    if (i == arguments.end())
-    {
-        return emptyArg;
-    }
-    else
-    {
-        return i->second;
-    }
-}
-
-void ArgumentParser::usage(char* const argv[])
-{
-    std::cerr << "Usage: " << argv[0] << " options\n";
-    std::cerr << "Options:\n";
-    std::cerr << " --help                                    Print this menu\n";
-    std::cerr << " --path=<Dbus Object path>                 Dbus Object path. "
-                 "Ex: /xyz/openbmc_project/state/watchdog/host0\n";
-    std::cerr << " --service=<Dbus Service name>             Dbus Service "
-                 "name. Ex: xyz.openbmc_project.State.Watchdog.Host\n";
-    std::cerr << " [--target=<systemd unit>]                 Systemd unit to "
-                 "be called on timeout for all actions but NONE. "
-                 "Deprecated, use --action_target instead.\n";
-    std::cerr << " [--action_target=<action>=<systemd unit>] Map of action to "
-                 "systemd unit to be called on timeout if that action is "
-                 "set for ExpireAction when the timer expires.\n";
-    std::cerr << " [--fallback_action=<action>]              Enables the "
-                 "watchdog even when disabled via the dbus interface. "
-                 "Perform this action when the fallback expires.\n";
-    std::cerr << " [--fallback_interval=<interval in ms>]    Enables the "
-                 "watchdog even when disabled via the dbus interface. "
-                 "Waits for this interval before performing the fallback "
-                 "action.\n";
-    std::cerr << " [--fallback_always]                       Enables the "
-                 "watchdog even when disabled by the dbus interface. "
-                 "This option is only valid with a fallback specified.\n";
-    std::cerr << " [--continue]                              Continue daemon "
-                 "after watchdog timeout.\n";
-}
-} // namespace watchdog
-} // namespace phosphor
diff --git a/argument.hpp b/argument.hpp
deleted file mode 100644
index df61de1..0000000
--- a/argument.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-
-#include <getopt.h>
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace phosphor
-{
-namespace watchdog
-{
-/** @brief Class ArgumentParser - Encapsulates parsing command line options
- *                                and populating arguments
- */
-class ArgumentParser
-{
-  public:
-    ArgumentParser() = delete;
-    ~ArgumentParser() = default;
-    ArgumentParser(const ArgumentParser&) = delete;
-    ArgumentParser& operator=(const ArgumentParser&) = delete;
-    ArgumentParser(ArgumentParser&&) = default;
-    ArgumentParser& operator=(ArgumentParser&&) = default;
-
-    /** @brief Constructs ArgumentParser object
-     *
-     *  @param argc - the main function's argc passed as is
-     *  @param argv - the main function's argv passed as is
-     *  @return Object constructed
-     */
-    ArgumentParser(int argc, char* const argv[]);
-
-    /** @brief Given an option, returns its argument(optarg)
-     *
-     *  @param opt - command line option string
-     *
-     *  @return argument which is a standard optarg
-     */
-    const std::vector<std::string>& operator[](const std::string& opt);
-
-    /** @brief Displays usage
-     *
-     *  @param argv - the main function's argv passed as is
-     */
-    static void usage(char* const argv[]);
-
-    /** @brief Set to 'true' when an option is passed */
-    static const std::string trueString;
-
-  private:
-    /** @brief Option to argument mapping */
-    std::map<const std::string, std::vector<std::string>> arguments;
-
-    /** @brief Array of struct options as needed by getopt_long */
-    static const option options[];
-
-    /** @brief optstring as needed by getopt_long */
-    static const char* optionStr;
-};
-
-} // namespace watchdog
-} // namespace phosphor
diff --git a/configure.ac b/configure.ac
index cd4ae00..b1e9527 100644
--- a/configure.ac
+++ b/configure.ac
@@ -31,6 +31,11 @@
         AC_SUBST(GTEST_MAIN_LIBS)
     ])
 
+# We need the header only CLI library
+AC_CHECK_HEADERS([CLI/CLI.hpp], [], [
+    AC_MSG_ERROR([Could not find CLI11 CLI/CLI.hpp])
+])
+
 AC_ARG_ENABLE([oe-sdk],
     AS_HELP_STRING([--enable-oe-sdk], [Link testcases absolutely against OE SDK so they can be ran within it.])
 )
diff --git a/mainapp.cpp b/mainapp.cpp
index b98b108..1aa69e5 100644
--- a/mainapp.cpp
+++ b/mainapp.cpp
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include "argument.hpp"
 #include "watchdog.hpp"
 
+#include <CLI/CLI.hpp>
 #include <iostream>
 #include <optional>
 #include <phosphor-logging/elog-errors.hpp>
@@ -25,17 +25,9 @@
 #include <string>
 #include <xyz/openbmc_project/Common/error.hpp>
 
-using phosphor::watchdog::ArgumentParser;
 using phosphor::watchdog::Watchdog;
 using sdbusplus::xyz::openbmc_project::State::server::convertForMessage;
 
-static void exitWithError(const char* err, char** argv)
-{
-    ArgumentParser::usage(argv);
-    std::cerr << "ERROR: " << err << "\n";
-    exit(EXIT_FAILURE);
-}
-
 void printActionTargetMap(const Watchdog::ActionTargetMap& actionTargetMap)
 {
     std::cerr << "Action Targets:\n";
@@ -47,74 +39,107 @@
     std::cerr << std::flush;
 }
 
+void printFallback(const Watchdog::Fallback& fallback)
+{
+    std::cerr << "Fallback Options:\n";
+    std::cerr << "  Action: " << convertForMessage(fallback.action) << "\n";
+    std::cerr << "  Interval(ms): " << std::dec << fallback.interval << "\n";
+    std::cerr << "  Always re-execute: " << std::boolalpha << fallback.always
+              << "\n";
+    std::cerr << std::flush;
+}
+
 int main(int argc, char* argv[])
 {
     using namespace phosphor::logging;
     using InternalFailure =
         sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
-    // Read arguments.
-    auto options = ArgumentParser(argc, argv);
 
-    // Parse out continue argument.
-    auto continueParam = (options)["continue"];
-    // Default it to exit on watchdog timeout
-    auto continueAfterTimeout = false;
-    if (!continueParam.empty())
-    {
-        continueAfterTimeout = true;
-    }
+    CLI::App app{"Canonical openbmc host watchdog daemon"};
 
-    // Parse out path argument.
-    auto pathParam = (options)["path"];
-    if (pathParam.empty())
-    {
-        exitWithError("Path not specified.", argv);
-    }
-    if (pathParam.size() > 1)
-    {
-        exitWithError("Multiple paths specified.", argv);
-    }
-    auto path = pathParam.back();
+    // Service related options
+    const std::string serviceGroup = "Service Options";
+    std::string path;
+    app.add_option("-p,--path", path,
+                   "DBus Object Path. "
+                   "Ex: /xyz/openbmc_project/state/watchdog/host0")
+        ->required()
+        ->group(serviceGroup);
+    std::string service;
+    app.add_option("-s,--service", service,
+                   "DBus Service Name. "
+                   "Ex: xyz.openbmc_project.State.Watchdog.Host")
+        ->required()
+        ->group(serviceGroup);
+    bool continueAfterTimeout;
+    app.add_flag("-c,--continue", continueAfterTimeout,
+                 "Continue daemon after watchdog timeout")
+        ->group(serviceGroup);
 
-    // Parse out service name argument
-    auto serviceParam = (options)["service"];
-    if (serviceParam.empty())
-    {
-        exitWithError("Service not specified.", argv);
-    }
-    if (serviceParam.size() > 1)
-    {
-        exitWithError("Multiple services specified.", argv);
-    }
-    auto service = serviceParam.back();
+    // Target related options
+    const std::string targetGroup = "Target Options";
+    std::optional<std::string> target;
+    app.add_option("-t,--target", target,
+                   "Systemd unit to be called on "
+                   "timeout for all actions but NONE. "
+                   "Deprecated, use --action_target instead.")
+        ->group(targetGroup);
+    std::vector<std::string> actionTargets;
+    app.add_option("-a,--action_target", actionTargets,
+                   "Map of action to "
+                   "systemd unit to be called on timeout if that action is "
+                   "set for ExpireAction when the timer expires.")
+        ->group(targetGroup);
 
-    // Parse out target argument. It is fine if the caller does not
-    // pass this if they are not interested in calling into any target
-    // on meeting a condition.
-    auto targetParam = (options)["target"];
-    if (targetParam.size() > 1)
-    {
-        exitWithError("Multiple targets specified.", argv);
-    }
+    // Fallback related options
+    const std::string fallbackGroup = "Fallback Options";
+    std::optional<std::string> fallbackAction;
+    auto fallbackActionOpt =
+        app.add_option("-f,--fallback_action", fallbackAction,
+                       "Enables the "
+                       "watchdog even when disabled via the dbus interface. "
+                       "Perform this action when the fallback expires.")
+            ->group(fallbackGroup);
+    std::optional<unsigned> fallbackIntervalMs;
+    auto fallbackIntervalOpt =
+        app.add_option("-i,--fallback_interval", fallbackIntervalMs,
+                       "Enables the "
+                       "watchdog even when disabled via the dbus interface. "
+                       "Waits for this interval before performing the fallback "
+                       "action.")
+            ->group(fallbackGroup);
+    fallbackIntervalOpt->needs(fallbackActionOpt);
+    fallbackActionOpt->needs(fallbackIntervalOpt);
+    bool fallbackAlways;
+    app.add_flag("-e,--fallback_always", fallbackAlways,
+                 "Enables the "
+                 "watchdog even when disabled by the dbus interface. "
+                 "This option is only valid with a fallback specified")
+        ->group(fallbackGroup)
+        ->needs(fallbackActionOpt)
+        ->needs(fallbackIntervalOpt);
+
+    CLI11_PARSE(app, argc, argv);
+
+    // Put together a list of actions and associated systemd targets
+    // The new --action_target options take precedence over the legacy
+    // --target
     Watchdog::ActionTargetMap actionTargetMap;
-    if (!targetParam.empty())
+    if (target)
     {
-        auto target = targetParam.back();
-        actionTargetMap[Watchdog::Action::HardReset] = target;
-        actionTargetMap[Watchdog::Action::PowerOff] = target;
-        actionTargetMap[Watchdog::Action::PowerCycle] = target;
+        actionTargetMap[Watchdog::Action::HardReset] = *target;
+        actionTargetMap[Watchdog::Action::PowerOff] = *target;
+        actionTargetMap[Watchdog::Action::PowerCycle] = *target;
     }
-
-    // Parse out the action_target arguments. We allow one target to map
-    // to an action. These targets can replace the target specified above.
-    for (const auto& actionTarget : (options)["action_target"])
+    for (const auto& actionTarget : actionTargets)
     {
         size_t keyValueSplit = actionTarget.find("=");
         if (keyValueSplit == std::string::npos)
         {
-            exitWithError(
-                "Invalid action_target format, expect <action>=<target>.",
-                argv);
+            std::cerr << "Invalid action_target format, "
+                         "expect <action>=<target>."
+                      << std::endl;
+            return 1;
         }
 
         std::string key = actionTarget.substr(0, keyValueSplit);
@@ -128,72 +153,42 @@
         }
         catch (const sdbusplus::exception::InvalidEnumString&)
         {
-            exitWithError("Bad action specified.", argv);
+            std::cerr << "Bad action specified: " << key << std::endl;
+            return 1;
         }
 
         // Detect duplicate action target arguments
         if (actionTargetMap.find(action) != actionTargetMap.end())
         {
-            exitWithError("Duplicate action specified", argv);
+            std::cerr << "Got duplicate action: " << key << std::endl;
+            return 1;
         }
 
         actionTargetMap[action] = std::move(value);
     }
     printActionTargetMap(actionTargetMap);
 
-    // Parse out the fallback settings for the watchdog. Note that we require
-    // both of the fallback arguments to do anything here, but having a fallback
-    // is entirely optional.
-    auto fallbackActionParam = (options)["fallback_action"];
-    auto fallbackIntervalParam = (options)["fallback_interval"];
-    if (fallbackActionParam.empty() ^ fallbackIntervalParam.empty())
+    // Build the fallback option used for the Watchdog
+    std::optional<Watchdog::Fallback> maybeFallback;
+    if (fallbackAction)
     {
-        exitWithError("Only one of the fallback options was specified.", argv);
-    }
-    if (fallbackActionParam.size() > 1 || fallbackIntervalParam.size() > 1)
-    {
-        exitWithError("Multiple fallbacks specified.", argv);
-    }
-    std::optional<Watchdog::Fallback> fallback;
-    if (!fallbackActionParam.empty())
-    {
-        Watchdog::Action action;
+        Watchdog::Fallback fallback;
         try
         {
-            action =
-                Watchdog::convertActionFromString(fallbackActionParam.back());
+            fallback.action =
+                Watchdog::convertActionFromString(*fallbackAction);
         }
         catch (const sdbusplus::exception::InvalidEnumString&)
         {
-            exitWithError("Bad action specified.", argv);
+            std::cerr << "Bad fallback action specified: " << *fallbackAction
+                      << std::endl;
+            return 1;
         }
-        uint64_t interval;
-        try
-        {
-            interval = std::stoull(fallbackIntervalParam.back());
-        }
-        catch (const std::logic_error&)
-        {
-            exitWithError("Failed to convert fallback interval to integer.",
-                          argv);
-        }
-        fallback = Watchdog::Fallback{
-            .action = action,
-            .interval = interval,
-            .always = false,
-        };
-    }
+        fallback.interval = *fallbackIntervalMs;
+        fallback.always = fallbackAlways;
 
-    auto fallbackAlwaysParam = (options)["fallback_always"];
-    if (!fallbackAlwaysParam.empty())
-    {
-        if (!fallback)
-        {
-            exitWithError("Specified the fallback should always be enabled but "
-                          "no fallback provided.",
-                          argv);
-        }
-        fallback->always = true;
+        printFallback(fallback);
+        maybeFallback = std::move(fallback);
     }
 
     try
@@ -212,7 +207,7 @@
 
         // Create a watchdog object
         Watchdog watchdog(bus, path.c_str(), event, std::move(actionTargetMap),
-                          std::move(fallback));
+                          std::move(maybeFallback));
 
         // Claim the bus
         bus.request_name(service.c_str());
diff --git a/test/Makefile.am b/test/Makefile.am
index 1c44162..bb1d048 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -4,8 +4,7 @@
 TESTS = $(check_PROGRAMS)
 
 # Build/add utest to test suite
-check_PROGRAMS = argument_test \
-                 watchdog_test
+check_PROGRAMS = watchdog_test
 
 utestCPPFLAGS = $(GTEST_MAIN_CFLAGS) \
                 $(AM_CPPFLAGS) \
@@ -24,13 +23,8 @@
                $(PHOSPHOR_LOGGING_LIBS) \
                $(PHOSPHOR_DBUS_INTERFACES_LIBS)
 
-argument_test_CPPFLAGS = ${utestCPPFLAGS}
-argument_test_CXXFLAGS = ${utestCXXFLAGS}
-argument_test_LDFLAGS = ${utestLDFLAGS}
-
 watchdog_test_CPPFLAGS = ${utestCPPFLAGS}
 watchdog_test_CXXFLAGS = ${utestCXXFLAGS}
 watchdog_test_LDFLAGS = ${utestLDFLAGS}
 
-argument_test_SOURCES = ../argument.cpp argument_test.cpp
 watchdog_test_SOURCES = ../watchdog.cpp watchdog_test.cpp
diff --git a/test/argument_test.cpp b/test/argument_test.cpp
deleted file mode 100644
index 3cb5dc9..0000000
--- a/test/argument_test.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#include "argument_test.hpp"
-
-#include "argument.hpp"
-
-#include <string>
-#include <vector>
-
-static const std::string expected_path1 = "/arg1-test-path";
-static const std::string expected_target1 = "t1.target";
-static const std::string expected_target2 = "t2.target";
-
-// Allow for a single unrecognized option then the Usage printout
-static const std::string invalid_arg_regex =
-    "^[^\n]*unrecognized option[^\n]*\nUsage: ";
-
-static const std::string clean_usage_regex = "^Usage: ";
-
-namespace phosphor
-{
-namespace watchdog
-{
-
-void ArgumentTest::SetUp()
-{
-    arg0 = "argument_test";
-}
-
-/** @brief ArgumentParser should return no values if given no options */
-TEST_F(ArgumentTest, NoOptions)
-{
-    char* const args[] = {&arg0[0], nullptr};
-    ArgumentParser ap(sizeof(args) / sizeof(char*) - 1, args);
-    EXPECT_EQ(std::vector<std::string>({}), ap["path"]);
-    EXPECT_EQ(std::vector<std::string>({}), ap["continue"]);
-    EXPECT_EQ(std::vector<std::string>({}), ap["arbitrary_unknown"]);
-}
-
-/** @brief ArgumentParser should return true for an existing no-arg option
- *         Make sure we don't parse arguments if an option takes none
- *         Also make sure we don't populate options not used.
- */
-TEST_F(ArgumentTest, LongOptionNoArg)
-{
-    std::string arg_continue = "--continue";
-    std::string arg_extra = "not-a-bool";
-    char* const args[] = {&arg0[0], &arg_continue[0], &arg_extra[0], nullptr};
-    ArgumentParser ap(sizeof(args) / sizeof(char*) - 1, args);
-    EXPECT_EQ(std::vector<std::string>({}), ap["path"]);
-    EXPECT_EQ(std::vector<std::string>({ArgumentParser::trueString}),
-              ap["continue"]);
-}
-
-/** @brief ArgumentParser should return a string for long options that
- *         take an arg
- */
-TEST_F(ArgumentTest, LongOptionRequiredArg)
-{
-    std::string arg_path = "--path";
-    std::string arg_path_val = expected_path1;
-    std::string arg_extra = "/unused-path";
-    char* const args[] = {&arg0[0], &arg_path[0], &arg_path_val[0],
-                          &arg_extra[0], nullptr};
-    ArgumentParser ap(sizeof(args) / sizeof(char*) - 1, args);
-    EXPECT_EQ(std::vector<std::string>({expected_path1}), ap["path"]);
-}
-
-/** @brief ArgumentParser should return a string for long options that
- *         accept an argument when passed an argument inline
- */
-TEST_F(ArgumentTest, LongOptionInlineArg)
-{
-    std::string arg_path = "--path=" + expected_path1;
-    std::string arg_extra = "/unused-path";
-    char* const args[] = {&arg0[0], &arg_path[0], &arg_extra[0], nullptr};
-    ArgumentParser ap(sizeof(args) / sizeof(char*) - 1, args);
-    EXPECT_EQ(std::vector<std::string>({expected_path1}), ap["path"]);
-}
-
-/** @brief ArgumentParser should return a string for short options that
- *         accept an argument.
- */
-TEST_F(ArgumentTest, ShortOptionRequiredArg)
-{
-    std::string arg_path = "-p";
-    std::string arg_path_val = expected_path1;
-    std::string arg_extra = "/unused-path";
-    char* const args[] = {&arg0[0], &arg_path[0], &arg_path_val[0],
-                          &arg_extra[0], nullptr};
-    ArgumentParser ap(sizeof(args) / sizeof(char*) - 1, args);
-    EXPECT_EQ(std::vector<std::string>({expected_path1}), ap["path"]);
-}
-
-/** @brief ArgumentParser should be able to handle parsing multiple options
- *         Make sure this works for no-arg and required-arg type options
- *         Make sure this works between short and long options
- */
-TEST_F(ArgumentTest, MultiOptionOverride)
-{
-    std::string arg_continue_short = "-c";
-    std::string arg_path = "--path=" + expected_path1;
-    std::string arg_continue_long = "--continue";
-    std::string arg_target = "--target=" + expected_target2;
-    std::string arg_target_short = "-t";
-    std::string arg_target_val = expected_target1;
-    char* const args[] = {&arg0[0],           &arg_continue_short[0],
-                          &arg_path[0],       &arg_continue_long[0],
-                          &arg_target[0],     &arg_target_short[0],
-                          &arg_target_val[0], nullptr};
-    ArgumentParser ap(sizeof(args) / sizeof(char*) - 1, args);
-    EXPECT_EQ(std::vector<std::string>({expected_path1}), ap["path"]);
-    EXPECT_EQ(std::vector<std::string>(
-                  {ArgumentParser::trueString, ArgumentParser::trueString}),
-              ap["continue"]);
-    EXPECT_EQ(std::vector<std::string>({expected_target2, expected_target1}),
-              ap["target"]);
-}
-
-/** @brief ArgumentParser should print usage information when given a help
- *         argument anywhere in the arguments array
- */
-TEST_F(ArgumentTest, ShortOptionHelp)
-{
-    std::string arg_extra = "extra";
-    std::string arg_help = "-h";
-    char* const args[] = {&arg0[0], &arg_extra[0], &arg_help[0], nullptr};
-    EXPECT_EXIT(ArgumentParser(sizeof(args) / sizeof(char*) - 1, args),
-                ::testing::ExitedWithCode(255), clean_usage_regex);
-}
-
-/** @brief ArgumentParser should print usage information when given a help
- *         argument anywhere in the arguments array
- */
-TEST_F(ArgumentTest, LongOptionHelp)
-{
-    std::string arg_help = "--help";
-    std::string arg_extra = "extra";
-    char* const args[] = {&arg0[0], &arg_help[0], &arg_extra[0], nullptr};
-    EXPECT_EXIT(ArgumentParser(sizeof(args) / sizeof(char*) - 1, args),
-                ::testing::ExitedWithCode(255), clean_usage_regex);
-}
-
-/** @brief ArgumentParser should print an invalid argument error and
- *         usage information when given an invalid argument anywhere
- *         in the arguments array
- */
-TEST_F(ArgumentTest, InvalidOptionHelp)
-{
-    std::string arg_continue = "--continue";
-    std::string arg_bad = "--bad_arg";
-    std::string arg_target = "--target=/unused-path";
-    char* const args[] = {&arg0[0], &arg_continue[0], &arg_bad[0],
-                          &arg_target[0], nullptr};
-    EXPECT_EXIT(ArgumentParser(sizeof(args) / sizeof(char*) - 1, args),
-                ::testing::ExitedWithCode(255), invalid_arg_regex);
-}
-
-} // namespace watchdog
-} // namespace phosphor
diff --git a/test/argument_test.hpp b/test/argument_test.hpp
deleted file mode 100644
index 46e8762..0000000
--- a/test/argument_test.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include <gtest/gtest.h>
-
-namespace phosphor
-{
-namespace watchdog
-{
-
-class ArgumentTest : public testing::Test
-{
-  protected:
-    void SetUp() override;
-
-    std::string arg0;
-};
-
-} // namespace watchdog
-} // namespace phosphor