SERVER-48367 Remove all _envp usage

36 files changed, 407 insertions, 680 deletions

diff --git a/src/mongo/base/initializer.cpp b/src/mongo/base/initializer.cpp
index 6cff1611be0..89799707ce9 100644
--- a/src/mongo/base/initializer.cpp
+++ b/src/mongo/base/initializer.cpp
@@ -42,11 +42,7 @@
 
 namespace mongo {
 
-Initializer::Initializer() {}
-Initializer::~Initializer() {}
-
-Status Initializer::executeInitializers(const InitializerContext::ArgumentVector& args,
-                                        const InitializerContext::EnvironmentMap& env) {
+Status Initializer::executeInitializers(const std::vector<std::string>& args) {
     auto oldState = std::exchange(_lifecycleState, State::kInitializing);
     invariant(oldState == State::kUninitialized, "invalid initializer state transition");
 
@@ -57,7 +53,7 @@ Status Initializer::executeInitializers(const InitializerContext::ArgumentVector
     }
     _graph.freeze();
 
-    InitializerContext context(args, env);
+    InitializerContext context(args);
 
     for (const auto& nodeName : _sortedNodes) {
         InitializerDependencyNode* node = _graph.getInitializerNode(nodeName);
@@ -119,36 +115,16 @@ Status Initializer::executeDeinitializers() {
     return Status::OK();
 }
 
-Status runGlobalInitializers(const InitializerContext::ArgumentVector& args,
-                             const InitializerContext::EnvironmentMap& env) {
-    return getGlobalInitializer().executeInitializers(args, env);
-}
-
-Status runGlobalInitializers(int argc, const char* const* argv, const char* const* envp) {
-    InitializerContext::ArgumentVector args(argc);
-    std::copy(argv, argv + argc, args.begin());
-
-    InitializerContext::EnvironmentMap env;
-
-    if (envp) {
-        for (; *envp; ++envp) {
-            const char* firstEqualSign = strchr(*envp, '=');
-            if (!firstEqualSign) {
-                return Status(ErrorCodes::BadValue, "malformed environment block");
-            }
-            env[std::string(*envp, firstEqualSign)] = std::string(firstEqualSign + 1);
-        }
-    }
-
-    return runGlobalInitializers(args, env);
+Status runGlobalInitializers(const std::vector<std::string>& argv) {
+    return getGlobalInitializer().executeInitializers(argv);
 }
 
 Status runGlobalDeinitializers() {
     return getGlobalInitializer().executeDeinitializers();
 }
 
-void runGlobalInitializersOrDie(int argc, const char* const* argv, const char* const* envp) {
-    Status status = runGlobalInitializers(argc, argv, envp);
+void runGlobalInitializersOrDie(const std::vector<std::string>& argv) {
+    Status status = runGlobalInitializers(argv);
     if (!status.isOK()) {
         std::cerr << "Failed global initialization: " << status << std::endl;
         quickExit(1);
diff --git a/src/mongo/base/initializer.h b/src/mongo/base/initializer.h
index 91b4c5e8183..131e3144477 100644
--- a/src/mongo/base/initializer.h
+++ b/src/mongo/base/initializer.h
@@ -47,13 +47,7 @@ namespace mongo {
  * execute in an order that respects the programmer-established prerequistes.
  */
 class Initializer {
-    Initializer(const Initializer&) = delete;
-    Initializer& operator=(const Initializer&) = delete;
-
 public:
-    Initializer();
-    ~Initializer();
-
     /**
      * Get the initializer dependency graph, presumably for the purpose of adding more nodes.
      */
@@ -67,8 +61,7 @@ public:
      * Returns Status::OK on success.  All other returns constitute initialization failures,
      * and the thing being initialized should be considered dead in the water.
      */
-    Status executeInitializers(const InitializerContext::ArgumentVector& args,
-                               const InitializerContext::EnvironmentMap& env);
+    Status executeInitializers(const std::vector<std::string>& args);
 
     Status executeDeinitializers();
 
@@ -94,16 +87,13 @@ private:
  * This means that the few initializers that might want to terminate the program by failing
  * should probably arrange to terminate the process themselves.
  */
-Status runGlobalInitializers(const InitializerContext::ArgumentVector& args,
-                             const InitializerContext::EnvironmentMap& env);
-
-Status runGlobalInitializers(int argc, const char* const* argv, const char* const* envp);
+Status runGlobalInitializers(const std::vector<std::string>& argv);
 
 /**
  * Same as runGlobalInitializers(), except prints a brief message to std::cerr
  * and terminates the process on failure.
  */
-void runGlobalInitializersOrDie(int argc, const char* const* argv, const char* const* envp);
+void runGlobalInitializersOrDie(const std::vector<std::string>& argv);
 
 /**
  * Run the global deinitializers. They will execute in reverse order from initialization.
diff --git a/src/mongo/base/initializer_context.h b/src/mongo/base/initializer_context.h
index 12a6fd23f3a..9ba23d69441 100644
--- a/src/mongo/base/initializer_context.h
+++ b/src/mongo/base/initializer_context.h
@@ -42,26 +42,15 @@ namespace mongo {
  * See mongo/base/initializer.h and mongo/base/initializer_dependency_graph.h for more details.
  */
 class InitializerContext {
-    InitializerContext(const InitializerContext&) = delete;
-    InitializerContext& operator=(const InitializerContext&) = delete;
-
 public:
-    typedef std::vector<std::string> ArgumentVector;
-    typedef std::map<std::string, std::string> EnvironmentMap;
-
-    InitializerContext(const ArgumentVector& args, const EnvironmentMap& env)
-        : _args(args), _env(env) {}
+    explicit InitializerContext(std::vector<std::string> args) : _args(std::move(args)) {}
 
-    const ArgumentVector& args() const {
+    const std::vector<std::string>& args() const {
         return _args;
     }
-    const EnvironmentMap& env() const {
-        return _env;
-    }
 
 private:
-    ArgumentVector _args;
-    EnvironmentMap _env;
+    std::vector<std::string> _args;
 };
 
 }  // namespace mongo
diff --git a/src/mongo/base/initializer_test.cpp b/src/mongo/base/initializer_test.cpp
index 86f281cc666..3598e26694f 100644
--- a/src/mongo/base/initializer_test.cpp
+++ b/src/mongo/base/initializer_test.cpp
@@ -298,8 +298,7 @@ TEST(InitializerTest, SuccessfulInitializationAndDeinitialization) {
     constructNormalDependencyGraph(&initializer);
     clearCounts();
 
-    ASSERT_OK(initializer.executeInitializers(InitializerContext::ArgumentVector(),
-                                              InitializerContext::EnvironmentMap()));
+    ASSERT_OK(initializer.executeInitializers({}));
 
     for (int i = 0; i < 9; ++i)
         ASSERT_EQUALS(INITIALIZED, globalStates[i]);
@@ -333,9 +332,7 @@ TEST(InitializerTest, Init5Misimplemented) {
                                deinitNoop);
     clearCounts();
 
-    ASSERT_EQUALS(ErrorCodes::UnknownError,
-                  initializer.executeInitializers(InitializerContext::ArgumentVector(),
-                                                  InitializerContext::EnvironmentMap()));
+    ASSERT_EQUALS(ErrorCodes::UnknownError, initializer.executeInitializers({}));
 
     ASSERT_EQUALS(INITIALIZED, globalStates[0]);
     ASSERT_EQUALS(INITIALIZED, globalStates[1]);
@@ -371,8 +368,7 @@ TEST(InitializerTest, Deinit2Misimplemented) {
                                deinit8);
     clearCounts();
 
-    ASSERT_OK(initializer.executeInitializers(InitializerContext::ArgumentVector(),
-                                              InitializerContext::EnvironmentMap()));
+    ASSERT_OK(initializer.executeInitializers({}));
 
     for (int i = 0; i < 9; ++i)
         ASSERT_EQUALS(INITIALIZED, globalStates[i]);
@@ -395,8 +391,7 @@ DEATH_TEST(InitializerTest, CannotAddInitializerAfterInitializing, "!frozen()")
     constructNormalDependencyGraph(&initializer);
     clearCounts();
 
-    ASSERT_OK(initializer.executeInitializers(InitializerContext::ArgumentVector(),
-                                              InitializerContext::EnvironmentMap()));
+    ASSERT_OK(initializer.executeInitializers({}));
 
     for (int i = 0; i < 9; ++i)
         ASSERT_EQUALS(INITIALIZED, globalStates[i]);
@@ -414,16 +409,12 @@ DEATH_TEST(InitializerTest, CannotDoubleInitialize, "invalid initializer state t
     constructNormalDependencyGraph(&initializer);
     clearCounts();
 
-    ASSERT_OK(initializer.executeInitializers(InitializerContext::ArgumentVector(),
-                                              InitializerContext::EnvironmentMap()));
+    ASSERT_OK(initializer.executeInitializers({}));
 
     for (int i = 0; i < 9; ++i)
         ASSERT_EQUALS(INITIALIZED, globalStates[i]);
 
-    initializer
-        .executeInitializers(InitializerContext::ArgumentVector(),
-                             InitializerContext::EnvironmentMap())
-        .ignore();
+    initializer.executeInitializers({}).ignore();
 }
 
 DEATH_TEST(InitializerTest,
@@ -441,8 +432,7 @@ DEATH_TEST(InitializerTest, CannotDoubleDeinitialize, "invalid initializer state
     constructNormalDependencyGraph(&initializer);
     clearCounts();
 
-    ASSERT_OK(initializer.executeInitializers(InitializerContext::ArgumentVector(),
-                                              InitializerContext::EnvironmentMap()));
+    ASSERT_OK(initializer.executeInitializers({}));
 
     for (int i = 0; i < 9; ++i)
         ASSERT_EQUALS(INITIALIZED, globalStates[i]);
diff --git a/src/mongo/client/sdam/json_test_arg_parser.cpp b/src/mongo/client/sdam/json_test_arg_parser.cpp
index 51f995c133a..8a27e328114 100644
--- a/src/mongo/client/sdam/json_test_arg_parser.cpp
+++ b/src/mongo/client/sdam/json_test_arg_parser.cpp
@@ -51,7 +51,7 @@ ArgParser::ArgParser(int argc, char* argv[]) {
         MONGO_UNREACHABLE;
     }
 
-    ret = parser.run(options, toStringVector(argc, argv), {}, &environment);
+    ret = parser.run(options, toStringVector(argc, argv), &environment);
     if (argc <= 1 || !ret.isOK() || environment.count("help")) {
         if (!ret.isOK()) {
             std::cerr << "An error occurred: " << ret.toString() << std::endl;
diff --git a/src/mongo/db/mongod.cpp b/src/mongo/db/mongod.cpp
index 3fd8f53c106..d16cb1954f3 100644
--- a/src/mongo/db/mongod.cpp
+++ b/src/mongo/db/mongod.cpp
@@ -39,14 +39,11 @@
 // WindowsCommandLine object converts these wide character strings to a UTF-8 coded equivalent
 // and makes them available through the argv() and envp() members.  This enables mongoDbMain()
 // to process UTF-8 encoded arguments and environment variables without regard to platform.
-int wmain(int argc, wchar_t* argvW[], wchar_t* envpW[]) {
-    mongo::WindowsCommandLine wcl(argc, argvW, envpW);
-    int exitCode = mongo::mongod_main(argc, wcl.argv(), wcl.envp());
-    mongo::quickExit(exitCode);
+int wmain(int argc, wchar_t* argvW[]) {
+    mongo::quickExit(mongo::mongod_main(argc, mongo::WindowsCommandLine(argc, argvW).argv()));
 }
 #else
-int main(int argc, char* argv[], char** envp) {
-    int exitCode = mongo::mongod_main(argc, argv, envp);
-    mongo::quickExit(exitCode);
+int main(int argc, char* argv[]) {
+    mongo::quickExit(mongo::mongod_main(argc, argv));
 }
 #endif
diff --git a/src/mongo/db/mongod_main.cpp b/src/mongo/db/mongod_main.cpp
index 00ec1ec3814..4d093d7824a 100644
--- a/src/mongo/db/mongod_main.cpp
+++ b/src/mongo/db/mongod_main.cpp
@@ -1321,7 +1321,7 @@ void shutdownTask(const ShutdownTaskArgs& shutdownArgs) {
 
 }  // namespace
 
-int mongod_main(int argc, char* argv[], char** envp) {
+int mongod_main(int argc, char* argv[]) {
     ThreadSafetyContext::getThreadSafetyContext()->forbidMultiThreading();
 
     registerShutdownTask(shutdownTask);
@@ -1330,7 +1330,7 @@ int mongod_main(int argc, char* argv[], char** envp) {
 
     srand(static_cast<unsigned>(curTimeMicros64()));
 
-    Status status = mongo::runGlobalInitializers(argc, argv, envp);
+    Status status = mongo::runGlobalInitializers(std::vector<std::string>(argv, argv + argc));
     if (!status.isOK()) {
         LOGV2_FATAL_OPTIONS(
             20574,
diff --git a/src/mongo/db/mongod_main.h b/src/mongo/db/mongod_main.h
index 0e5a8e06383..0ff4bce69e5 100644
--- a/src/mongo/db/mongod_main.h
+++ b/src/mongo/db/mongod_main.h
@@ -29,6 +29,6 @@
 
 namespace mongo {
 
-int mongod_main(int argc, char* argv[], char** envp);
+int mongod_main(int argc, char* argv[]);
 
 }  // namespace mongo
diff --git a/src/mongo/db/server_options_test.cpp b/src/mongo/db/server_options_test.cpp
index 81d1b975f35..26510278e08 100644
--- a/src/mongo/db/server_options_test.cpp
+++ b/src/mongo/db/server_options_test.cpp
@@ -116,9 +116,8 @@ TEST_F(Verbosity, Default) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -139,9 +138,8 @@ TEST_F(Verbosity, CommandLineImplicit) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("--verbose");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -163,9 +161,8 @@ TEST_F(Verbosity, CommandLineString) {
     argv.push_back("binaryname");
     argv.push_back("--verbose");
     argv.push_back("vvvv");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -187,9 +184,8 @@ TEST_F(Verbosity, CommandLineStringDisguisedLongForm) {
     argv.push_back("binaryname");
     argv.push_back("-verbose");
     argv.push_back("vvvv");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -211,9 +207,8 @@ TEST_F(Verbosity, CommandLineEmptyString) {
     argv.push_back("binaryname");
     argv.push_back("--verbose");
     argv.push_back("");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(options, argv, &environment));
 }
 
 TEST_F(Verbosity, CommandLineBadString) {
@@ -227,9 +222,8 @@ TEST_F(Verbosity, CommandLineBadString) {
     argv.push_back("binaryname");
     argv.push_back("--verbose");
     argv.push_back("beloud");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_NOT_OK(::mongo::validateServerOptions(environment));
 }
@@ -244,9 +238,8 @@ TEST_F(Verbosity, CommandLineBadStringOnlyDash) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("-");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(options, argv, &environment));
 }
 
 TEST_F(Verbosity, CommandLineBadStringOnlyTwoDashes) {
@@ -259,9 +252,8 @@ TEST_F(Verbosity, CommandLineBadStringOnlyTwoDashes) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("--");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 }
 
 TEST_F(Verbosity, INIConfigString) {
@@ -275,11 +267,10 @@ TEST_F(Verbosity, INIConfigString) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini", "verbose=vvvv");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -301,11 +292,10 @@ TEST_F(Verbosity, INIConfigBadString) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini", "verbose=beloud");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_NOT_OK(::mongo::validateServerOptions(environment));
 }
@@ -321,11 +311,10 @@ TEST_F(Verbosity, INIConfigEmptyString) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini", "verbose=");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -347,11 +336,10 @@ TEST_F(Verbosity, JSONConfigString) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ \"systemLog.verbosity\" : 4 }");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -375,11 +363,10 @@ TEST_F(Verbosity, MultipleSourcesMultipleOptions) {
     argv.push_back("config.json");
     argv.push_back("--verbose");
     argv.push_back("vvv");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ \"systemLog.verbosity\" : 4 }");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -405,7 +392,6 @@ TEST_F(Verbosity, YAMLConfigStringLogComponent) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      "systemLog:\n"
@@ -418,7 +404,7 @@ TEST_F(Verbosity, YAMLConfigStringLogComponent) {
                      "            journal:\n"
                      "                verbosity: 2\n");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -515,9 +501,8 @@ TEST(SetupOptions, SlowMsCommandLineParamParsesSuccessfully) {
     argv.push_back("binaryname");
     argv.push_back("--slowms");
     argv.push_back("300");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -539,11 +524,10 @@ TEST(SetupOptions, SlowMsParamInitializedSuccessfullyFromINIConfigFile) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini", "slowms=300");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -565,13 +549,12 @@ TEST(SetupOptions, SlowMsParamInitializedSuccessfullyFromYAMLConfigFile) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      "operationProfiling:\n"
                      "    slowOpThresholdMs: 300\n");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -592,9 +575,8 @@ TEST(SetupOptions, NonNumericSlowMsCommandLineOptionFailsToParse) {
     argv.push_back("binaryname");
     argv.push_back("--slowms");
     argv.push_back("invalid");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(options, argv, &environment));
 }
 
 TEST(SetupOptions, NonNumericSlowMsYAMLConfigOptionFailsToParse) {
@@ -608,13 +590,12 @@ TEST(SetupOptions, NonNumericSlowMsYAMLConfigOptionFailsToParse) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      "operationProfiling:\n"
                      "    slowOpThresholdMs: invalid\n");
 
-    ASSERT_NOT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(options, argv, &environment));
 }
 
 TEST(SetupOptions, SampleRateCommandLineParamParsesSuccessfully) {
@@ -628,9 +609,8 @@ TEST(SetupOptions, SampleRateCommandLineParamParsesSuccessfully) {
     argv.push_back("binaryname");
     argv.push_back("--slowOpSampleRate");
     argv.push_back("0.5");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -652,11 +632,10 @@ TEST(SetupOptions, SampleRateParamInitializedSuccessfullyFromINIConfigFile) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini", "slowOpSampleRate=0.5");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -678,13 +657,12 @@ TEST(SetupOptions, SampleRateParamInitializedSuccessfullyFromYAMLConfigFile) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      "operationProfiling:\n"
                      "    slowOpSampleRate: 0.5\n");
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
 
     ASSERT_OK(::mongo::validateServerOptions(environment));
     ASSERT_OK(::mongo::canonicalizeServerOptions(&environment));
@@ -705,9 +683,8 @@ TEST(SetupOptions, NonNumericSampleRateCommandLineOptionFailsToParse) {
     argv.push_back("binaryname");
     argv.push_back("--slowOpSampleRate");
     argv.push_back("invalid");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(options, argv, &environment));
 }
 
 TEST(SetupOptions, NonNumericSampleRateYAMLConfigOptionFailsToParse) {
@@ -722,13 +699,12 @@ TEST(SetupOptions, NonNumericSampleRateYAMLConfigOptionFailsToParse) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      "operationProfiling:\n"
                      "    slowOpSampleRate: invalid\n");
 
-    ASSERT_NOT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(options, argv, &environment));
 }
 
 #if !defined(_WIN32) && !(defined(__APPLE__) && TARGET_OS_TV)
diff --git a/src/mongo/db/traffic_reader_main.cpp b/src/mongo/db/traffic_reader_main.cpp
index c907b74c979..5f257cf627c 100644
--- a/src/mongo/db/traffic_reader_main.cpp
+++ b/src/mongo/db/traffic_reader_main.cpp
@@ -48,11 +48,11 @@
 
 using namespace mongo;
 
-int main(int argc, char* argv[], char** envp) {
+int main(int argc, char* argv[]) {
 
     setupSignalHandlers();
 
-    Status status = mongo::runGlobalInitializers(argc, argv, envp);
+    Status status = mongo::runGlobalInitializers(std::vector<std::string>(argv, argv + argc));
     if (!status.isOK()) {
         std::cerr << "Failed global initialization: " << status << std::endl;
         return EXIT_FAILURE;
diff --git a/src/mongo/dbtests/dbtests.cpp b/src/mongo/dbtests/dbtests.cpp
index 03a3eb6fd01..c61e4ae7031 100644
--- a/src/mongo/dbtests/dbtests.cpp
+++ b/src/mongo/dbtests/dbtests.cpp
@@ -172,13 +172,13 @@ WriteContextForTests::WriteContextForTests(OperationContext* opCtx, StringData n
 }  // namespace mongo
 
 
-int dbtestsMain(int argc, char** argv, char** envp) {
+int dbtestsMain(int argc, char** argv) {
     ::mongo::setTestCommandsEnabled(true);
     ::mongo::TestingProctor::instance().setEnabled(true);
     ::mongo::setupSynchronousSignalHandlers();
     mongo::dbtests::initWireSpec();
 
-    mongo::runGlobalInitializersOrDie(argc, argv, envp);
+    mongo::runGlobalInitializersOrDie(std::vector<std::string>(argv, argv + argc));
     serverGlobalParams.featureCompatibility.setVersion(
         ServerGlobalParams::FeatureCompatibility::Version::kFullyUpgradedTo46);
     repl::ReplSettings replSettings;
@@ -231,14 +231,11 @@ int dbtestsMain(int argc, char** argv, char** envp) {
 // WindowsCommandLine object converts these wide character strings to a UTF-8 coded equivalent
 // and makes them available through the argv() and envp() members.  This enables dbtestsMain()
 // to process UTF-8 encoded arguments and environment variables without regard to platform.
-int wmain(int argc, wchar_t* argvW[], wchar_t* envpW[]) {
-    WindowsCommandLine wcl(argc, argvW, envpW);
-    int exitCode = dbtestsMain(argc, wcl.argv(), wcl.envp());
-    quickExit(exitCode);
+int wmain(int argc, wchar_t* argvW[]) {
+    quickExit(dbtestsMain(argc, WindowsCommandLine(argc, argvW).argv()));
 }
 #else
-int main(int argc, char* argv[], char** envp) {
-    int exitCode = dbtestsMain(argc, argv, envp);
-    quickExit(exitCode);
+int main(int argc, char* argv[]) {
+    quickExit(dbtestsMain(argc, argv));
 }
 #endif
diff --git a/src/mongo/embedded/embedded.cpp b/src/mongo/embedded/embedded.cpp
index 1236f123293..e7a4ef87453 100644
--- a/src/mongo/embedded/embedded.cpp
+++ b/src/mongo/embedded/embedded.cpp
@@ -190,11 +190,10 @@ void shutdown(ServiceContext* srvContext) {
 ServiceContext* initialize(const char* yaml_config) {
     srand(static_cast<unsigned>(curTimeMicros64()));
 
-    // yaml_config is passed to the options parser through the argc/argv interface that already
-    // existed. If it is nullptr then use 0 count which will be interpreted as empty string.
-    const char* argv[2] = {yaml_config, nullptr};
-
-    Status status = mongo::runGlobalInitializers(yaml_config ? 1 : 0, argv, nullptr);
+    std::vector<std::string> argv;
+    if (yaml_config)
+        argv.push_back(yaml_config);
+    Status status = mongo::runGlobalInitializers(argv);
     uassertStatusOKWithContext(status, "Global initilization failed");
     auto giGuard = makeGuard([] { mongo::runGlobalDeinitializers().ignore(); });
     setGlobalServiceContext(ServiceContext::make());
diff --git a/src/mongo/embedded/embedded_options_helpers.cpp b/src/mongo/embedded/embedded_options_helpers.cpp
index 6815584a9d0..51cf838c935 100644
--- a/src/mongo/embedded/embedded_options_helpers.cpp
+++ b/src/mongo/embedded/embedded_options_helpers.cpp
@@ -49,14 +49,9 @@ Status parseCommandLineOptions(int argc,
     // different options format and we therefore need to have parsed the command line options before
     // embedded::initialize() is called. However, as long as we store the options in the same place
     // they will be valid for embedded too.
-    std::vector<std::string> args;
-    std::map<std::string, std::string> env;
-
-    args.reserve(argc);
-    std::copy(argv, argv + argc, std::back_inserter(args));
-
-    optionenvironment::OptionsParser parser;
-    return parser.run(startupOptions, args, env, &optionenvironment::startupOptionsParsed);
+    return optionenvironment::OptionsParser{}.run(startupOptions,
+                                                  std::vector<std::string>(argv, argv + argc),
+                                                  &optionenvironment::startupOptionsParsed);
 }
 
 }  // namespace embedded_integration_helpers
diff --git a/src/mongo/embedded/embedded_options_parser_init.cpp b/src/mongo/embedded/embedded_options_parser_init.cpp
index 895fb94f9e0..1599668cf73 100644
--- a/src/mongo/embedded/embedded_options_parser_init.cpp
+++ b/src/mongo/embedded/embedded_options_parser_init.cpp
@@ -49,8 +49,7 @@ GlobalInitializerRegisterer startupOptionsInitializer(
         std::string config = !context->args().empty() ? context->args()[0] : "";
 
         OptionsParser parser;
-        Status ret =
-            parser.runConfigFile(startupOptions, config, context->env(), &startupOptionsParsed);
+        Status ret = parser.runConfigFile(startupOptions, config, &startupOptionsParsed);
         uassertStatusOKWithContext(ret, "Options parsing failed.");
 
         return Status::OK();
diff --git a/src/mongo/embedded/mongo_embedded/mongo_embedded_test.cpp b/src/mongo/embedded/mongo_embedded/mongo_embedded_test.cpp
index a3755223912..9e5bfd7038f 100644
--- a/src/mongo/embedded/mongo_embedded/mongo_embedded_test.cpp
+++ b/src/mongo/embedded/mongo_embedded/mongo_embedded_test.cpp
@@ -658,9 +658,8 @@ int main(const int argc, const char* const* const argv) {
         return EXIT_FAILURE;
     }
 
-    std::map<std::string, std::string> env;
     ret = moe::OptionsParser().run(
-        options, std::vector<std::string>(argv, argv + argc), env, &environment);
+        options, std::vector<std::string>(argv, argv + argc), &environment);
     if (!ret.isOK()) {
         std::cerr << options.helpString();
         return EXIT_FAILURE;
@@ -683,8 +682,7 @@ int main(const int argc, const char* const* const argv) {
     // The reason this works is that the unittest system relies on other systems being initialized
     // through global init and deinitialize just deinitializes systems that explicitly supports
     // deinit leaving the systems unittest needs initialized.
-    const char* null_argv[1] = {nullptr};
-    ret = mongo::runGlobalInitializers(0, null_argv, nullptr);
+    ret = mongo::runGlobalInitializers(std::vector<std::string>{});
     if (!ret.isOK()) {
         std::cerr << "Global initilization failed";
         return EXIT_FAILURE;
diff --git a/src/mongo/embedded/mongoc_embedded/mongoc_embedded_test.cpp b/src/mongo/embedded/mongoc_embedded/mongoc_embedded_test.cpp
index eff6c417320..6d8750b1058 100644
--- a/src/mongo/embedded/mongoc_embedded/mongoc_embedded_test.cpp
+++ b/src/mongo/embedded/mongoc_embedded/mongoc_embedded_test.cpp
@@ -259,12 +259,11 @@ using StatusPtr = std::unique_ptr<mongo_embedded_v1_status, StatusDestroy>;
 // These test functions cannot use the main() defined for unittests because they
 // call runGlobalInitializers(). The embedded C API calls mongoDbMain() which
 // calls runGlobalInitializers().
-int main(int argc, char** argv, char** envp) {
+int main(int argc, char** argv) {
 
     moe::OptionsParser parser;
     moe::Environment environment;
     moe::OptionSection options;
-    std::map<std::string, std::string> env;
 
     auto ret = mongo::embedded::addMongocEmbeddedTestOptions(&options);
     if (!ret.isOK()) {
@@ -272,8 +271,7 @@ int main(int argc, char** argv, char** envp) {
         return EXIT_FAILURE;
     }
 
-    std::vector<std::string> argVector(argv, argv + argc);
-    ret = parser.run(options, argVector, env, &environment);
+    ret = parser.run(options, std::vector<std::string>(argv, argv + argc), &environment);
     if (!ret.isOK()) {
         std::cerr << options.helpString();
         return EXIT_FAILURE;
diff --git a/src/mongo/embedded/stitch_support/stitch_support.cpp b/src/mongo/embedded/stitch_support/stitch_support.cpp
index 934f9185735..2613c62f2d0 100644
--- a/src/mongo/embedded/stitch_support/stitch_support.cpp
+++ b/src/mongo/embedded/stitch_support/stitch_support.cpp
@@ -123,8 +123,7 @@ ServiceContext* initialize() {
     // The global initializers can take arguments, which would normally be supplied on the command
     // line, but we assume that clients of this library will never want anything other than the
     // defaults for all configuration that would be controlled by these parameters.
-    Status status =
-        mongo::runGlobalInitializers(0 /* argc */, nullptr /* argv */, nullptr /* envp */);
+    Status status = mongo::runGlobalInitializers(std::vector<std::string>{});
     uassertStatusOKWithContext(status, "Global initialization failed");
     setGlobalServiceContext(ServiceContext::make());
     auto serviceContext = getGlobalServiceContext();
diff --git a/src/mongo/embedded/stitch_support/stitch_support_test.cpp b/src/mongo/embedded/stitch_support/stitch_support_test.cpp
index d46ba1b3281..75db9287db1 100644
--- a/src/mongo/embedded/stitch_support/stitch_support_test.cpp
+++ b/src/mongo/embedded/stitch_support/stitch_support_test.cpp
@@ -635,8 +635,7 @@ TEST_F(StitchSupportTest, TestUpsertProducesProperStatus) {
 // the Stitch Support Library intializer function that gets tested here.
 int main(const int argc, const char* const* const argv) {
     // See comment by the same code block in mongo_embedded_test.cpp
-    const char* null_argv[1] = {nullptr};
-    auto ret = mongo::runGlobalInitializers(0, null_argv, nullptr);
+    auto ret = mongo::runGlobalInitializers(std::vector<std::string>{});
     if (!ret.isOK()) {
         std::cerr << "Global initilization failed";
         return EXIT_FAILURE;
diff --git a/src/mongo/idl/config_option_test.cpp b/src/mongo/idl/config_option_test.cpp
index 3b7509a38b1..78bdf0df513 100644
--- a/src/mongo/idl/config_option_test.cpp
+++ b/src/mongo/idl/config_option_test.cpp
@@ -47,7 +47,7 @@ bool gEnableTestConfigOpt15 = false;
 namespace {
 
 Status parseArgv(const std::vector<std::string>& argv, moe::Environment* parsed) {
-    auto status = moe::OptionsParser().run(moe::startupOptions, argv, {}, parsed);
+    auto status = moe::OptionsParser().run(moe::startupOptions, argv, parsed);
     if (!status.isOK()) {
         return status;
     }
@@ -55,7 +55,7 @@ Status parseArgv(const std::vector<std::string>& argv, moe::Environment* parsed)
 }
 
 Status parseConfig(const std::string& config, moe::Environment* parsed) {
-    auto status = moe::OptionsParser().runConfigFile(moe::startupOptions, config, {}, parsed);
+    auto status = moe::OptionsParser().runConfigFile(moe::startupOptions, config, parsed);
     if (!status.isOK()) {
         return status;
     }
@@ -68,11 +68,11 @@ Status parseMixed(const std::vector<std::string>& argv,
     moe::OptionsParser mixedParser;
 
     moe::Environment conf;
-    uassertStatusOK(mixedParser.runConfigFile(moe::startupOptions, config, {}, &conf));
+    uassertStatusOK(mixedParser.runConfigFile(moe::startupOptions, config, &conf));
     uassertStatusOK(env->setAll(conf));
 
     moe::Environment cli;
-    uassertStatusOK(mixedParser.run(moe::startupOptions, argv, {}, &cli));
+    uassertStatusOK(mixedParser.run(moe::startupOptions, argv, &cli));
     uassertStatusOK(env->setAll(cli));
 
     return env->validate();
@@ -616,7 +616,7 @@ TEST(ConfigOptionNoInit, Opt1) {
         "Hello",
     });
     moe::Environment parsed;
-    ASSERT_OK(moe::OptionsParser().run(options, argv, {}, &parsed));
+    ASSERT_OK(moe::OptionsParser().run(options, argv, &parsed));
     ASSERT_OK(parsed.validate());
     ASSERT_OK(storeIDLTestConfigs(parsed));
 
diff --git a/src/mongo/s/mongos.cpp b/src/mongo/s/mongos.cpp
index d9cc1790464..131cbd4ee73 100644
--- a/src/mongo/s/mongos.cpp
+++ b/src/mongo/s/mongos.cpp
@@ -39,12 +39,11 @@
 // WindowsCommandLine object converts these wide character strings to a UTF-8 coded equivalent
 // and makes them available through the argv() and envp() members.  This enables mongoSMain()
 // to process UTF-8 encoded arguments and environment variables without regard to platform.
-int wmain(int argc, wchar_t* argvW[], wchar_t* envpW[]) {
-    mongo::WindowsCommandLine wcl(argc, argvW, envpW);
-    mongo::exitCleanly(mongo::mongos_main(argc, wcl.argv(), wcl.envp()));
+int wmain(int argc, wchar_t* argvW[]) {
+    mongo::exitCleanly(mongo::mongos_main(argc, mongo::WindowsCommandLine(argc, argvW).argv()));
 }
 #else
-int main(int argc, char* argv[], char** envp) {
-    mongo::exitCleanly(mongo::mongos_main(argc, argv, envp));
+int main(int argc, char* argv[]) {
+    mongo::exitCleanly(mongo::mongos_main(argc, argv));
 }
 #endif
diff --git a/src/mongo/s/mongos_main.cpp b/src/mongo/s/mongos_main.cpp
index 6894950f899..f045dd9b115 100644
--- a/src/mongo/s/mongos_main.cpp
+++ b/src/mongo/s/mongos_main.cpp
@@ -914,7 +914,7 @@ MONGO_INITIALIZER_GENERAL(setSSLManagerType, MONGO_NO_PREREQUISITES, ("SSLManage
 
 }  // namespace
 
-ExitCode mongos_main(int argc, char* argv[], char** envp) {
+ExitCode mongos_main(int argc, char* argv[]) {
     setMongos();
 
     if (argc < 1)
@@ -923,7 +923,7 @@ ExitCode mongos_main(int argc, char* argv[], char** envp) {
 
     setupSignalHandlers();
 
-    Status status = runGlobalInitializers(argc, argv, envp);
+    Status status = runGlobalInitializers(std::vector<std::string>(argv, argv + argc));
     if (!status.isOK()) {
         LOGV2_FATAL_OPTIONS(
             22865,
diff --git a/src/mongo/s/mongos_main.h b/src/mongo/s/mongos_main.h
index e68edc33563..37dd9512824 100644
--- a/src/mongo/s/mongos_main.h
+++ b/src/mongo/s/mongos_main.h
@@ -31,6 +31,6 @@
 
 namespace mongo {
 
-ExitCode mongos_main(int argc, char* argv[], char** envp);
+ExitCode mongos_main(int argc, char* argv[]);
 
 }  // namespace mongo
diff --git a/src/mongo/shell/mongo.cpp b/src/mongo/shell/mongo.cpp
index e6e0b199951..2dac76a86d9 100644
--- a/src/mongo/shell/mongo.cpp
+++ b/src/mongo/shell/mongo.cpp
@@ -34,12 +34,11 @@
 #include "mongo/util/text.h"
 
 #ifdef _WIN32
-int wmain(int argc, wchar_t* argvW[], wchar_t* envpW[]) {
-    mongo::WindowsCommandLine wcl(argc, argvW, envpW);
-    mongo::quickExit(mongo::mongo_main(argc, wcl.argv(), wcl.envp()));
+int wmain(int argc, wchar_t* argvW[]) {
+    mongo::quickExit(mongo::mongo_main(argc, mongo::WindowsCommandLine(argc, argvW).argv()));
 }
 #else   // #ifdef _WIN32
-int main(int argc, char* argv[], char** envp) {
-    mongo::quickExit(mongo::mongo_main(argc, argv, envp));
+int main(int argc, char* argv[]) {
+    mongo::quickExit(mongo::mongo_main(argc, argv));
 }
 #endif  // #ifdef _WIN32
diff --git a/src/mongo/shell/mongo_main.cpp b/src/mongo/shell/mongo_main.cpp
index c338fe921d7..5061079123a 100644
--- a/src/mongo/shell/mongo_main.cpp
+++ b/src/mongo/shell/mongo_main.cpp
@@ -702,7 +702,7 @@ bool mechanismRequiresPassword(const MongoURI& uri) {
 
 }  // namespace
 
-int mongo_main(int argc, char* argv[], char** envp) {
+int mongo_main(int argc, char* argv[]) {
 
     try {
 
@@ -724,7 +724,7 @@ int mongo_main(int argc, char* argv[], char** envp) {
 
         mongo::shell_utils::RecordMyLocation(argv[0]);
 
-        mongo::runGlobalInitializersOrDie(argc, argv, envp);
+        mongo::runGlobalInitializersOrDie(std::vector<std::string>(argv, argv + argc));
         setGlobalServiceContext(ServiceContext::make());
         // TODO This should use a TransportLayerManager or TransportLayerFactory
         auto serviceContext = getGlobalServiceContext();
diff --git a/src/mongo/shell/mongo_main.h b/src/mongo/shell/mongo_main.h
index b16b2ed5203..45250fc0271 100644
--- a/src/mongo/shell/mongo_main.h
+++ b/src/mongo/shell/mongo_main.h
@@ -29,6 +29,6 @@
 
 namespace mongo {
 
-int mongo_main(int argc, char* argv[], char** envp);
+int mongo_main(int argc, char* argv[]);
 
 }  // namespace mongo
diff --git a/src/mongo/tools/bridge.cpp b/src/mongo/tools/bridge.cpp
index 52336902ba7..e377fae9be8 100644
--- a/src/mongo/tools/bridge.cpp
+++ b/src/mongo/tools/bridge.cpp
@@ -453,7 +453,7 @@ DbResponse ServiceEntryPointBridge::handleRequest(OperationContext* opCtx, const
     }
 }
 
-int bridgeMain(int argc, char** argv, char** envp) {
+int bridgeMain(int argc, char** argv) {
 
     registerShutdownTask([&] {
         // NOTE: This function may be called at any time. It must not
@@ -472,7 +472,7 @@ int bridgeMain(int argc, char** argv, char** envp) {
     });
 
     setupSignalHandlers();
-    runGlobalInitializersOrDie(argc, argv, envp);
+    runGlobalInitializersOrDie(std::vector<std::string>(argv, argv + argc));
     startSignalProcessingThread(LogFileStatus::kNoLogFileToRotate);
 
     setGlobalServiceContext(ServiceContext::make());
@@ -512,14 +512,11 @@ int bridgeMain(int argc, char** argv, char** envp) {
 // WindowsCommandLine object converts these wide character strings to a UTF-8 coded equivalent
 // and makes them available through the argv() and envp() members.  This enables bridgeMain()
 // to process UTF-8 encoded arguments and environment variables without regard to platform.
-int wmain(int argc, wchar_t* argvW[], wchar_t* envpW[]) {
-    mongo::WindowsCommandLine wcl(argc, argvW, envpW);
-    int exitCode = mongo::bridgeMain(argc, wcl.argv(), wcl.envp());
-    mongo::quickExit(exitCode);
+int wmain(int argc, wchar_t* argvW[]) {
+    mongo::quickExit(mongo::bridgeMain(argc, mongo::WindowsCommandLine(argc, argvW).argv()));
 }
 #else
-int main(int argc, char* argv[], char** envp) {
-    int exitCode = mongo::bridgeMain(argc, argv, envp);
-    mongo::quickExit(exitCode);
+int main(int argc, char* argv[]) {
+    mongo::quickExit(mongo::bridgeMain(argc, argv));
 }
 #endif
diff --git a/src/mongo/unittest/benchmark_main.cpp b/src/mongo/unittest/benchmark_main.cpp
index e116be4d938..9e76cbff81a 100644
--- a/src/mongo/unittest/benchmark_main.cpp
+++ b/src/mongo/unittest/benchmark_main.cpp
@@ -40,11 +40,11 @@
 #include "mongo/util/signal_handlers_synchronous.h"
 
 
-int main(int argc, char** argv, char** envp) {
+int main(int argc, char** argv) {
     ::mongo::clearSignalMask();
     ::mongo::setupSynchronousSignalHandlers();
 
-    ::mongo::runGlobalInitializersOrDie(argc, argv, envp);
+    ::mongo::runGlobalInitializersOrDie(std::vector<std::string>(argv, argv + argc));
     ::mongo::setGlobalServiceContext(::mongo::ServiceContext::make());
 
     // Copied from the BENCHMARK_MAIN macro.
diff --git a/src/mongo/unittest/integration_test_main.cpp b/src/mongo/unittest/integration_test_main.cpp
index 07f8c95b097..41e553fc3fa 100644
--- a/src/mongo/unittest/integration_test_main.cpp
+++ b/src/mongo/unittest/integration_test_main.cpp
@@ -72,10 +72,10 @@ ConnectionString getFixtureConnectionString() {
 }  // namespace unittest
 }  // namespace mongo
 
-int main(int argc, char** argv, char** envp) {
+int main(int argc, char** argv) {
     setupSynchronousSignalHandlers();
     TestingProctor::instance().setEnabled(true);
-    runGlobalInitializersOrDie(argc, argv, envp);
+    runGlobalInitializersOrDie(std::vector<std::string>(argv, argv + argc));
     setTestCommandsEnabled(true);
     setGlobalServiceContext(ServiceContext::make());
     quickExit(unittest::Suite::run(std::vector<std::string>(), "", "", 1));
diff --git a/src/mongo/unittest/unittest_main.cpp b/src/mongo/unittest/unittest_main.cpp
index 39e59923d10..a43805b0944 100644
--- a/src/mongo/unittest/unittest_main.cpp
+++ b/src/mongo/unittest/unittest_main.cpp
@@ -50,12 +50,14 @@ using mongo::Status;
 
 namespace moe = ::mongo::optionenvironment;
 
-int main(int argc, char** argv, char** envp) {
+int main(int argc, char** argv) {
+    std::vector<std::string> argVec(argv, argv + argc);
+
     ::mongo::clearSignalMask();
     ::mongo::setupSynchronousSignalHandlers();
 
     ::mongo::TestingProctor::instance().setEnabled(true);
-    ::mongo::runGlobalInitializersOrDie(argc, argv, envp);
+    ::mongo::runGlobalInitializersOrDie(argVec);
     ::mongo::setTestCommandsEnabled(true);
 
     moe::OptionSection options;
@@ -68,9 +70,7 @@ int main(int argc, char** argv, char** envp) {
 
     moe::OptionsParser parser;
     moe::Environment environment;
-    std::map<std::string, std::string> env;
-    std::vector<std::string> argVector(argv, argv + argc);
-    Status ret = parser.run(options, argVector, env, &environment);
+    Status ret = parser.run(options, argVec, &environment);
     if (!ret.isOK()) {
         std::cerr << options.helpString();
         return EXIT_FAILURE;
diff --git a/src/mongo/util/net/ssl_options_test.cpp b/src/mongo/util/net/ssl_options_test.cpp
index 168cc2ff954..76ad7f48d0b 100644
--- a/src/mongo/util/net/ssl_options_test.cpp
+++ b/src/mongo/util/net/ssl_options_test.cpp
@@ -169,10 +169,9 @@ TEST(SetupOptions, tlsModeDisabled) {
     argv.push_back("binaryname");
     argv.push_back("--tlsMode");
     argv.push_back("disabled");
-    std::map<std::string, std::string> env_map;
 
     OptionsParserTester parser;
-    ASSERT_OK(parser.run(moe::startupOptions, argv, env_map, &moe::startupOptionsParsed));
+    ASSERT_OK(parser.run(moe::startupOptions, argv, &moe::startupOptionsParsed));
     ASSERT_OK(storeSSLServerOptions());
     ASSERT_EQ(::mongo::sslGlobalParams.sslMode.load(), ::mongo::sslGlobalParams.SSLMode_disabled);
 }
@@ -188,10 +187,9 @@ TEST(SetupOptions, sslModeDisabled) {
     argv.push_back("binaryname");
     argv.push_back("--sslMode");
     argv.push_back("disabled");
-    std::map<std::string, std::string> env_map;
 
     OptionsParserTester parser;
-    ASSERT_OK(parser.run(moe::startupOptions, argv, env_map, &moe::startupOptionsParsed));
+    ASSERT_OK(parser.run(moe::startupOptions, argv, &moe::startupOptionsParsed));
     ASSERT_OK(storeSSLServerOptions());
     ASSERT_EQ(::mongo::sslGlobalParams.sslMode.load(), ::mongo::sslGlobalParams.SSLMode_disabled);
 }
@@ -232,10 +230,9 @@ TEST(SetupOptions, tlsModeRequired) {
     argv.push_back("TLS1_1");
     argv.push_back("--tlsLogVersions");
     argv.push_back("TLS1_2");
-    std::map<std::string, std::string> env_map;
 
     OptionsParserTester parser;
-    ASSERT_OK(parser.run(moe::startupOptions, argv, env_map, &moe::startupOptionsParsed));
+    ASSERT_OK(parser.run(moe::startupOptions, argv, &moe::startupOptionsParsed));
     ASSERT_OK(storeSSLServerOptions());
 
     ASSERT_EQ(::mongo::sslGlobalParams.sslMode.load(), ::mongo::sslGlobalParams.SSLMode_requireSSL);
@@ -299,10 +296,9 @@ TEST(SetupOptions, sslModeRequired) {
     argv.push_back("TLS1_1");
     argv.push_back("--tlsLogVersions");
     argv.push_back("TLS1_0");
-    std::map<std::string, std::string> env_map;
 
     OptionsParserTester parser;
-    ASSERT_OK(parser.run(moe::startupOptions, argv, env_map, &moe::startupOptionsParsed));
+    ASSERT_OK(parser.run(moe::startupOptions, argv, &moe::startupOptionsParsed));
     ASSERT_OK(storeSSLServerOptions());
 
     ASSERT_EQ(::mongo::sslGlobalParams.sslMode.load(), ::mongo::sslGlobalParams.SSLMode_requireSSL);
@@ -346,10 +342,9 @@ TEST(SetupOptions, tlsModeRequiredCertificateSelector) {
     argv.push_back("subject=Subject 1");
     argv.push_back("--tlsClusterCertificateSelector");
     argv.push_back("subject=Subject 2");
-    std::map<std::string, std::string> env_map;
 
     OptionsParserTester parser;
-    ASSERT_OK(parser.run(moe::startupOptions, argv, env_map, &moe::startupOptionsParsed));
+    ASSERT_OK(parser.run(moe::startupOptions, argv, &moe::startupOptionsParsed));
     ASSERT_OK(storeSSLServerOptions());
 
     ASSERT_EQ(::mongo::sslGlobalParams.sslMode.load(), ::mongo::sslGlobalParams.SSLMode_requireSSL);
@@ -372,10 +367,9 @@ TEST(SetupOptions, sslModeRequiredCertificateSelector) {
     argv.push_back("subject=Subject 1");
     argv.push_back("--sslClusterCertificateSelector");
     argv.push_back("subject=Subject 2");
-    std::map<std::string, std::string> env_map;
 
     OptionsParserTester parser;
-    ASSERT_OK(parser.run(moe::startupOptions, argv, env_map, &moe::startupOptionsParsed));
+    ASSERT_OK(parser.run(moe::startupOptions, argv, &moe::startupOptionsParsed));
     ASSERT_OK(storeSSLServerOptions());
 
     ASSERT_EQ(::mongo::sslGlobalParams.sslMode.load(), ::mongo::sslGlobalParams.SSLMode_requireSSL);
@@ -395,9 +389,8 @@ TEST(SetupOptions, disableNonSSLConnectionLoggingFalse) {
     argv.push_back("binaryname");
     argv.push_back("--setParameter");
     argv.push_back("disableNonSSLConnectionLogging=false");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
     ASSERT_OK(mongo::storeServerOptions(environment));
 
     ASSERT_EQ(::mongo::sslGlobalParams.disableNonSSLConnectionLogging, false);
@@ -415,9 +408,8 @@ TEST(SetupOptions, disableNonTLSConnectionLoggingFalse) {
     argv.push_back("binaryname");
     argv.push_back("--setParameter");
     argv.push_back("disableNonTLSConnectionLogging=false");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
     Status storeRet = mongo::storeServerOptions(environment);
 
     ASSERT_EQ(::mongo::sslGlobalParams.disableNonSSLConnectionLogging, false);
@@ -435,9 +427,8 @@ TEST(SetupOptions, disableNonSSLConnectionLoggingTrue) {
     argv.push_back("binaryname");
     argv.push_back("--setParameter");
     argv.push_back("disableNonSSLConnectionLogging=true");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
     Status storeRet = mongo::storeServerOptions(environment);
 
     ASSERT_EQ(::mongo::sslGlobalParams.disableNonSSLConnectionLogging, true);
@@ -455,9 +446,8 @@ TEST(SetupOptions, disableNonTLSConnectionLoggingTrue) {
     argv.push_back("binaryname");
     argv.push_back("--setParameter");
     argv.push_back("disableNonTLSConnectionLogging=true");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
     Status storeRet = mongo::storeServerOptions(environment);
 
     ASSERT_EQ(::mongo::sslGlobalParams.disableNonSSLConnectionLogging, true);
@@ -476,9 +466,8 @@ TEST(SetupOptions, disableNonTLSConnectionLoggingInvalid) {
     argv.push_back("disableNonTLSConnectionLogging=false");
     argv.push_back("--setParameter");
     argv.push_back("disableNonSSLConnectionLogging=false");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(options, argv, env_map, &environment));
+    ASSERT_OK(parser.run(options, argv, &environment));
     ASSERT_NOT_OK(mongo::storeServerOptions(environment));
 }
 
diff --git a/src/mongo/util/options_parser/options_parser.cpp b/src/mongo/util/options_parser/options_parser.cpp
index 6d456fcc45d..ba151a6784d 100644
--- a/src/mongo/util/options_parser/options_parser.cpp
+++ b/src/mongo/util/options_parser/options_parser.cpp
@@ -1752,7 +1752,6 @@ StatusWith<OptionsParser::ConfigExpand> parseConfigExpand(const Environment& cli
  */
 Status OptionsParser::run(const OptionSection& options,
                           const std::vector<std::string>& argvOriginal,
-                          const std::map<std::string, std::string>& env,  // XXX: Currently unused
                           Environment* environment) {
     Environment commandLineEnvironment;
     Environment configEnvironment;
@@ -1855,11 +1854,9 @@ Status OptionsParser::run(const OptionSection& options,
     return Status::OK();
 }
 
-Status OptionsParser::runConfigFile(
-    const OptionSection& options,
-    const std::string& config,
-    const std::map<std::string, std::string>& env,  // Unused, interface consistent with run()
-    Environment* configEnvironment) {
+Status OptionsParser::runConfigFile(const OptionSection& options,
+                                    const std::string& config,
+                                    Environment* configEnvironment) {
     // Add values from the provided config file
     Status ret = parseConfigFile(options, config, configEnvironment, ConfigExpand());
     if (!ret.isOK()) {
diff --git a/src/mongo/util/options_parser/options_parser.h b/src/mongo/util/options_parser/options_parser.h
index 0dcc5db5c15..411323a267d 100644
--- a/src/mongo/util/options_parser/options_parser.h
+++ b/src/mongo/util/options_parser/options_parser.h
@@ -110,19 +110,15 @@ public:
      *  file.  For binaries that do not support config files, the "config" option should not be
      *  registered in the OptionSection.
      */
-    Status run(const OptionSection&,
+    Status run(const OptionSection& options,
                const std::vector<std::string>& argv,
-               const std::map<std::string, std::string>& env,
-               Environment*);
+               Environment* env);
 
     /** Handles parsing of a YAML or INI formatted string. The
      *  OptionSection be a description of the allowed options.  This function populates the
      *  given Environment with the results but does not call validate on the Environment.
      */
-    Status runConfigFile(const OptionSection&,
-                         const std::string& config,
-                         const std::map<std::string, std::string>& env,
-                         Environment*);
+    Status runConfigFile(const OptionSection& options, const std::string& config, Environment* env);
 
     /**
      * Flags controlling whether or not __rest and/or __exec directives in a
diff --git a/src/mongo/util/options_parser/options_parser_init.cpp b/src/mongo/util/options_parser/options_parser_init.cpp
index d6e20ffe045..304a6d1d152 100644
--- a/src/mongo/util/options_parser/options_parser_init.cpp
+++ b/src/mongo/util/options_parser/options_parser_init.cpp
@@ -44,7 +44,7 @@ namespace {
 
 MONGO_STARTUP_OPTIONS_PARSE(StartupOptions)(InitializerContext* context) {
     OptionsParser parser;
-    Status ret = parser.run(startupOptions, context->args(), context->env(), &startupOptionsParsed);
+    Status ret = parser.run(startupOptions, context->args(), &startupOptionsParsed);
     if (!ret.isOK()) {
         std::cerr << ret.reason() << std::endl;
         // TODO: Figure out if there's a use case for this help message ever being different
diff --git a/src/mongo/util/options_parser/options_parser_test.cpp b/src/mongo/util/options_parser/options_parser_test.cpp
index 7c2b223633e..25023d717b1 100644
--- a/src/mongo/util/options_parser/options_parser_test.cpp
+++ b/src/mongo/util/options_parser/options_parser_test.cpp
@@ -89,10 +89,9 @@ TEST(Registration, EmptySingleName) {
     // This should fail now, because we didn't specify that these options were not valid in the
     // INI config or on the command line
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
     moe::OptionsParser parser;
     moe::Environment environment;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     moe::OptionSection testOptsValid;
     try {
@@ -108,7 +107,7 @@ TEST(Registration, EmptySingleName) {
 
     // This should pass now, because we specified that these options were not valid in the INI
     // config or on the command line
-    ASSERT_OK(parser.run(testOptsValid, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOptsValid, argv, &environment));
 }
 
 TEST(Registration, DuplicateSingleName) {
@@ -372,10 +371,9 @@ TEST(Parsing, Good) {
     argv.push_back("--port");
     argv.push_back("5");
     argv.push_back("--help");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("help"), &value));
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -397,10 +395,9 @@ TEST(Parsing, SubSection) {
     argv.push_back("binaryname");
     argv.push_back("--port");
     argv.push_back("5");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
     ASSERT_OK(value.get(&port));
@@ -421,10 +418,9 @@ TEST(Parsing, StringVector) {
     argv.push_back("val1");
     argv.push_back("--multival");
     argv.push_back("val2");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::vector<std::string> multival;
     std::vector<std::string>::iterator multivalit;
@@ -451,10 +447,9 @@ TEST(Parsing, StringMap) {
     argv.push_back("key2=value2");
     argv.push_back("--multival");
     argv.push_back("key3=");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::map<std::string, std::string> multival;
     std::map<std::string, std::string>::iterator multivalit;
@@ -484,10 +479,9 @@ TEST(Parsing, StringMapDuplicateKey) {
     argv.push_back("key1=value1");
     argv.push_back("--multival");
     argv.push_back("key1=value2");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, Positional) {
@@ -503,10 +497,9 @@ TEST(Parsing, Positional) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("positional");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::string positional;
     ASSERT_OK(value.get(&positional));
@@ -527,10 +520,9 @@ TEST(Parsing, PositionalTooMany) {
     argv.push_back("binaryname");
     argv.push_back("positional");
     argv.push_back("extrapositional");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, PositionalAndFlag) {
@@ -549,10 +541,9 @@ TEST(Parsing, PositionalAndFlag) {
     argv.push_back("positional");
     argv.push_back("--port");
     argv.push_back("5");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::string positional;
     ASSERT_OK(value.get(&positional));
@@ -577,9 +568,8 @@ TEST(Parsing, PositionalMultiple) {
     argv.push_back("binaryname");
     argv.push_back("positional1");
     argv.push_back("positional2");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::vector<std::string> positional;
@@ -605,9 +595,8 @@ TEST(Parsing, PositionalMultipleExtra) {
     argv.push_back("positional1");
     argv.push_back("positional2");
     argv.push_back("positional2");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, PositionalMultipleUnlimited) {
@@ -627,9 +616,8 @@ TEST(Parsing, PositionalMultipleUnlimited) {
     argv.push_back("positional3");
     argv.push_back("positional4");
     argv.push_back("positional5");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::vector<std::string> positional;
@@ -663,9 +651,8 @@ TEST(Parsing, PositionalMultipleAndFlag) {
     argv.push_back("--port");
     argv.push_back("5");
     argv.push_back("positional2");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::vector<std::string> positional;
@@ -692,9 +679,8 @@ TEST(Parsing, NeedArg) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("--port");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, BadArg) {
@@ -710,9 +696,8 @@ TEST(Parsing, BadArg) {
     argv.push_back("binaryname");
     argv.push_back("--port");
     argv.push_back("string");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, ExtraArg) {
@@ -728,9 +713,8 @@ TEST(Parsing, ExtraArg) {
     argv.push_back("binaryname");
     argv.push_back("--help");
     argv.push_back("string");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, DefaultValue) {
@@ -745,9 +729,8 @@ TEST(Parsing, DefaultValue) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -769,9 +752,8 @@ TEST(Parsing, DefaultValueOverride) {
     argv.push_back("binaryname");
     argv.push_back("--port");
     argv.push_back("6");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -795,9 +777,8 @@ TEST(Parsing, DefaultValuesNotInBSON) {
     argv.push_back("binaryname");
     argv.push_back("--val1");
     argv.push_back("6");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     mongo::BSONObj expected = BSON("val1" << 6);
     ASSERT_BSONOBJ_EQ(expected, environment.toBSON());
@@ -817,9 +798,8 @@ TEST(Parsing, ImplicitValue) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("--port");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -840,9 +820,8 @@ TEST(Parsing, ImplicitValueDefault) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -865,9 +844,8 @@ TEST(Parsing, ImplicitValueOverride) {
     argv.push_back("binaryname");
     argv.push_back("--port");
     argv.push_back("5");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -889,9 +867,8 @@ TEST(Parsing, ImplicitValueOverrideWithEqualsSign) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("--port=5");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -913,10 +890,9 @@ TEST(Parsing, ShortName) {
     argv.push_back("-p");
     argv.push_back("5");
     argv.push_back("-h");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("help"), &value));
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -935,9 +911,8 @@ TEST(Style, NoSticky) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("-oa");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Style, NoGuessing) {
@@ -951,9 +926,8 @@ TEST(Style, NoGuessing) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("--hel");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Style, LongDisguises) {
@@ -967,9 +941,8 @@ TEST(Style, LongDisguises) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("-help");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("help"), &value));
     bool help;
@@ -1007,9 +980,8 @@ TEST(Style, Verbosity) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("-vvvvvv");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     moe::Value value;
     for (std::string s = "vv"; s.length() <= 12; s.append("v")) {
@@ -1037,11 +1009,10 @@ TEST(INIConfigFile, Basic) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("default.conf");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "port=5");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -1061,11 +1032,10 @@ TEST(INIConfigFile, Empty) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("default.conf");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(INIConfigFile, Override) {
@@ -1083,11 +1053,10 @@ TEST(INIConfigFile, Override) {
     argv.push_back("default.conf");
     argv.push_back("--port");
     argv.push_back("6");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "port=5");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -1109,11 +1078,10 @@ TEST(INIConfigFile, Comments) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("default.conf");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "# port=5\nstr=NotCommented");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_NOT_OK(environment.get(moe::Key("port"), &value));
     ASSERT_OK(environment.get(moe::Key("str"), &value));
@@ -1152,11 +1120,10 @@ TEST(INIConfigFile, Switches) {
     argv.push_back("--config");
     argv.push_back("default.conf");
     argv.push_back("--switch1");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "switch2=true\nswitch3=false\nswitch5=");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     bool switch1;
     ASSERT_OK(environment.get(moe::Key("switch1"), &switch1));
     ASSERT_TRUE(switch1);
@@ -1190,13 +1157,12 @@ TEST(INIConfigFile, Monkeys) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("default.conf");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf",
                      "\t this = false \n#that = true\n #another = whocares"
                      "\n\n other = monkeys ");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("this"), &value));
     bool thisValue;
@@ -1224,11 +1190,10 @@ TEST(INIConfigFile, DefaultValueOverride) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("default.conf");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "port=6");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -1250,12 +1215,11 @@ TEST(INIConfigFile, StringVector) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini", "multival = val1\nmultival = val2");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::vector<std::string> multival;
     std::vector<std::string>::iterator multivalit;
@@ -1280,7 +1244,6 @@ TEST(INIConfigFile, StringMap) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini",
                      "multival = key1=value1\n"
@@ -1288,7 +1251,7 @@ TEST(INIConfigFile, StringMap) {
                      "multival = key3=");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::map<std::string, std::string> multival;
     std::map<std::string, std::string>::iterator multivalit;
@@ -1318,13 +1281,12 @@ TEST(INIConfigFile, StringMapDuplicateKey) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.ini");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini",
                      "multival = key1=value1\n"
                      "multival = key1=value2");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(JSONConfigFile, Basic) {
@@ -1340,11 +1302,10 @@ TEST(JSONConfigFile, Basic) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ port : 5 }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -1364,11 +1325,10 @@ TEST(JSONConfigFile, Empty) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(JSONConfigFile, EmptyObject) {
@@ -1383,11 +1343,10 @@ TEST(JSONConfigFile, EmptyObject) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{}");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(JSONConfigFile, Override) {
@@ -1405,12 +1364,11 @@ TEST(JSONConfigFile, Override) {
     argv.push_back("config.json");
     argv.push_back("--port");
     argv.push_back("6");
-    std::map<std::string, std::string> env_map;
 
 
     parser.setConfig("config.json", "{ port : 5 }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -1430,11 +1388,10 @@ TEST(JSONConfigFile, UnregisteredOption) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ port : 5 }");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(JSONConfigFile, DuplicateOption) {
@@ -1450,11 +1407,10 @@ TEST(JSONConfigFile, DuplicateOption) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ port : 5, port : 5 }");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(JSONConfigFile, TypeChecking) {
@@ -1497,29 +1453,28 @@ TEST(JSONConfigFile, TypeChecking) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     // Test StringVector type
     std::vector<std::string> stringVectorVal;
 
     parser.setConfig("config.json", "{ stringVectorVal : \"scalar\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVectorVal : \"true\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVectorVal : \"5\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVectorVal : [ [ \"string\" ], true, 1, 1.0 ] }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a string vector type and treat it as an array of strings, even if the
     // elements are not surrounded by quotes
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVectorVal : [ \"string\", bare, true, 1, 1.0 ] }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVectorVal"), &value));
     std::vector<std::string>::iterator stringVectorValIt;
     ASSERT_OK(value.get(&stringVectorVal));
@@ -1538,25 +1493,25 @@ TEST(JSONConfigFile, TypeChecking) {
     bool boolVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "{ boolVal : \"lies\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ boolVal : truth }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ boolVal : 1 }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a bool type and try to convert it to a bool, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "{ boolVal : \"true\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("boolVal"), &value));
     ASSERT_OK(value.get(&boolVal));
     ASSERT_EQUALS(boolVal, true);
     environment = moe::Environment();
     parser.setConfig("config.json", "{ boolVal : false }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("boolVal"), &value));
     ASSERT_OK(value.get(&boolVal));
     ASSERT_EQUALS(boolVal, false);
@@ -1565,34 +1520,34 @@ TEST(JSONConfigFile, TypeChecking) {
     double doubleVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "{ doubleVal : \"double the monkeys\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ doubleVal : true }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a double type and try to convert it to a double, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "{ doubleVal : 1.5 }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, 1.5);
     environment = moe::Environment();
     parser.setConfig("config.json", "{ doubleVal : -1.5 }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, -1.5);
     environment = moe::Environment();
     parser.setConfig("config.json", "{ doubleVal : \"3.14\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, 3.14);
     environment = moe::Environment();
     parser.setConfig("config.json", "{ doubleVal : \"-3.14\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, -3.14);
@@ -1601,29 +1556,29 @@ TEST(JSONConfigFile, TypeChecking) {
     int intVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "{ intVal : \"hungry hippos\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ intVal : 1.5 }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ intVal : 18446744073709551617 }");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ intVal : true }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as an int type and try to convert it to a int, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "{ intVal : \"5\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("intVal"), &value));
     ASSERT_OK(value.get(&intVal));
     ASSERT_EQUALS(intVal, 5);
 
     environment = moe::Environment();
     parser.setConfig("config.json", "{ intVal : \"-5\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("intVal"), &value));
     ASSERT_OK(value.get(&intVal));
     ASSERT_EQUALS(intVal, -5);
@@ -1632,29 +1587,29 @@ TEST(JSONConfigFile, TypeChecking) {
     long longVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "{ longVal : \"in an eating race\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ longVal : 1.5 }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ longVal : 18446744073709551617 }");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ longVal : true }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a long type and try to convert it to a long, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "{ longVal : \"5\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("longVal"), &value));
     ASSERT_OK(value.get(&longVal));
     ASSERT_EQUALS(longVal, 5);
 
     environment = moe::Environment();
     parser.setConfig("config.json", "{ longVal : \"-5\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("longVal"), &value));
     ASSERT_OK(value.get(&longVal));
     ASSERT_EQUALS(longVal, -5);
@@ -1667,28 +1622,28 @@ TEST(JSONConfigFile, TypeChecking) {
     // surrounded by quotes
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVal : }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "");
 
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVal : \"1000\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "1000");
 
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVal : wat man }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "wat man");
 
     environment = moe::Environment();
     parser.setConfig("config.json", "{ stringVal : true 1 string 1.0 }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "true 1 string 1.0");
@@ -1697,26 +1652,26 @@ TEST(JSONConfigFile, TypeChecking) {
     unsigned long long unsignedLongLongVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedLongLongVal : \"unsigned hungry hippos\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedLongLongVal : 1.5 }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedLongLongVal : 18446744073709551617 }");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedLongLongVal : true }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedLongLongVal : \"-5\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as an unsigned long long type and try to convert it to an unsigned long long,
     // even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedLongLongVal : \"5\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("unsignedLongLongVal"), &value));
     ASSERT_OK(value.get(&unsignedLongLongVal));
     ASSERT_EQUALS(unsignedLongLongVal, 5ULL);
@@ -1725,25 +1680,25 @@ TEST(JSONConfigFile, TypeChecking) {
     unsigned unsignedVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedVal : \"unsigned hungry hippos\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedVal : 1.5 }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedVal : 18446744073709551617 }");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedVal : true }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedVal : \"-5\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as an unsigned type and try to convert it to an unsigned, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "{ unsignedVal : \"5\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("unsignedVal"), &value));
     ASSERT_OK(value.get(&unsignedVal));
     ASSERT_EQUALS(unsignedVal, 5U);
@@ -1752,25 +1707,25 @@ TEST(JSONConfigFile, TypeChecking) {
     bool switchVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "{ switchVal : \"lies\" }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ switchVal : truth }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "{ switchVal : 1 }");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a switch type and try to convert it to a bool, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "{ switchVal : \"true\" }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("switchVal"), &value));
     ASSERT_OK(value.get(&switchVal));
     ASSERT_EQUALS(switchVal, true);
     environment = moe::Environment();
     parser.setConfig("config.json", "{ switchVal : false }");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("switchVal"), &switchVal));
     ASSERT_FALSE(switchVal);
 }
@@ -1788,11 +1743,10 @@ TEST(JSONConfigFile, Nested) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ nested : { port : 5 } }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("nested.port"), &value));
     int port;
@@ -1813,11 +1767,10 @@ TEST(JSONConfigFile, Dotted) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ \"dotted.port\" : 5 }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("dotted.port"), &value));
     int port;
@@ -1841,11 +1794,10 @@ TEST(JSONConfigFile, DottedAndNested) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ \"dottednested.var1\" : 5, dottednested : { var2 : 6 } }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("dottednested.var1"), &value));
     int var1;
@@ -1871,12 +1823,11 @@ TEST(JSONConfigFile, StringVector) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ multival : [ \"val1\", \"val2\" ] }");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::vector<std::string> multival;
     std::vector<std::string>::iterator multivalit;
@@ -1901,13 +1852,12 @@ TEST(JSONConfigFile, StringMap) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json",
                      "{ multival : { key1 : \"value1\", key2 : \"value2\", key3 : \"\" } }");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::map<std::string, std::string> multival;
     std::map<std::string, std::string>::iterator multivalit;
@@ -1937,11 +1887,10 @@ TEST(JSONConfigFile, StringMapDuplicateKey) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ multival : { key1 : \"value1\", key1 : \"value2\" } }");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(JSONConfigFile, StringVectorNonString) {
@@ -1958,7 +1907,6 @@ TEST(JSONConfigFile, StringVectorNonString) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     // NOTE: The yaml config file just reads things as strings, and it's up to us to decide what
     // the type should be later.  This means that we can't tell the difference between when a
@@ -1966,7 +1914,7 @@ TEST(JSONConfigFile, StringVectorNonString) {
     parser.setConfig("config.json", "{ multival : [ 1, true ] }");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::vector<std::string> multival;
     std::vector<std::string>::iterator multivalit;
@@ -1991,11 +1939,10 @@ TEST(JSONConfigFile, DefaultValueOverride) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ port : 6 }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -2017,11 +1964,10 @@ TEST(Parsing, BadConfigFileOption) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("1");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, MapForScalarMismatch) {
@@ -2037,11 +1983,10 @@ TEST(Parsing, MapForScalarMismatch) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", R"cfg({ str: { elem: "val" } })cfg");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, ScalarForMapMismatch) {
@@ -2057,11 +2002,10 @@ TEST(Parsing, ScalarForMapMismatch) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", R"cfg({ str: "val" })cfg");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, ListForScalarMismatch) {
@@ -2077,11 +2021,10 @@ TEST(Parsing, ListForScalarMismatch) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", R"cfg({ str: ["val"] })cfg");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(Parsing, ScalarForListMismatch) {
@@ -2098,11 +2041,10 @@ TEST(Parsing, ScalarForListMismatch) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", R"cfg({ str: "val" })cfg");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ConfigFromFilesystem, JSONGood) {
@@ -2118,10 +2060,9 @@ TEST(ConfigFromFilesystem, JSONGood) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(TEST_CONFIG_PATH("good.json"));
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
     ASSERT_OK(value.get(&port));
@@ -2141,10 +2082,9 @@ TEST(ConfigFromFilesystem, INIGood) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(TEST_CONFIG_PATH("good.conf"));
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
     ASSERT_OK(value.get(&port));
@@ -2163,10 +2103,9 @@ TEST(ConfigFromFilesystem, Empty) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(TEST_CONFIG_PATH("empty.json"));
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ConfigFromFilesystem, Directory) {
@@ -2181,10 +2120,9 @@ TEST(ConfigFromFilesystem, Directory) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(TEST_CONFIG_PATH(""));
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ConfigFromFilesystem, NullByte) {
@@ -2201,10 +2139,9 @@ TEST(ConfigFromFilesystem, NullByte) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(TEST_CONFIG_PATH("nullByte.conf"));
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ConfigFromFilesystem, NullSubDir) {
@@ -2222,10 +2159,9 @@ TEST(ConfigFromFilesystem, NullSubDir) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(TEST_CONFIG_PATH("dirNullByte.conf"));
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 
@@ -2244,10 +2180,9 @@ TEST(ConfigFromFilesystem, NullTerminated) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(TEST_CONFIG_PATH("endStringNull.conf"));
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(JSONConfigFile, ComposingStringVector) {
@@ -2275,12 +2210,11 @@ TEST(JSONConfigFile, ComposingStringVector) {
     argv.push_back("val1");
     argv.push_back("--setParameter");
     argv.push_back("val2");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "{ setParameter : [ \"val3\", \"val4\" ] }");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("setParameter"), &value));
     std::vector<std::string> setParameter;
     std::vector<std::string>::iterator setParameterit;
@@ -2321,13 +2255,12 @@ TEST(JSONConfigFile, ComposingStringMap) {
     argv.push_back("key1=value1");
     argv.push_back("--setParameter");
     argv.push_back("key2=value2");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json",
                      "{ setParameter : { key2 : \"overridden_value2\", key3 : \"value3\" } }");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("setParameter"), &value));
     std::map<std::string, std::string> setParameter;
     std::map<std::string, std::string>::iterator setParameterIt;
@@ -2369,12 +2302,11 @@ TEST(INIConfigFile, ComposingStringVector) {
     argv.push_back("val1");
     argv.push_back("--setParameter");
     argv.push_back("val2");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("default.conf", "setParameter=val3\nsetParameter=val4");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("setParameter"), &value));
     std::vector<std::string> setParameter;
     std::vector<std::string>::iterator setParameterit;
@@ -2415,12 +2347,11 @@ TEST(INIConfigFile, ComposingStringMap) {
     argv.push_back("key1=value1");
     argv.push_back("--setParameter");
     argv.push_back("key2=value2");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.ini", "setParameter=key2=overridden_value2\nsetParameter=key3=value3");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("setParameter"), &value));
     std::map<std::string, std::string> setParameter;
     std::map<std::string, std::string>::iterator setParameterIt;
@@ -2462,12 +2393,11 @@ TEST(YAMLConfigFile, ComposingStringVector) {
     argv.push_back("val1");
     argv.push_back("--setParameter");
     argv.push_back("val2");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "setParameter : \n - \"val3\"\n - \"val4\"");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("setParameter"), &value));
     std::vector<std::string> setParameter;
     std::vector<std::string>::iterator setParameterit;
@@ -2508,7 +2438,6 @@ TEST(YAMLConfigFile, ComposingStringMap) {
     argv.push_back("key1=value1");
     argv.push_back("--setParameter");
     argv.push_back("key2=value2");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      // NOTE: Indentation is used to determine whether an option is in a sub
@@ -2517,7 +2446,7 @@ TEST(YAMLConfigFile, ComposingStringMap) {
                      "setParameter:\n key2: \"overridden_value2\"\n key3: \"value3\"");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("setParameter"), &value));
     std::map<std::string, std::string> setParameter;
     std::map<std::string, std::string>::iterator setParameterIt;
@@ -2545,9 +2474,8 @@ TEST(LegacyInterface, Good) {
     argv.push_back("binaryname");
     argv.push_back("--port");
     argv.push_back("5");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_TRUE(environment.count("port"));
     try {
         int port;
@@ -2567,9 +2495,8 @@ TEST(LegacyInterface, NotSpecified) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_FALSE(environment.count("port"));
 }
 
@@ -2584,9 +2511,8 @@ TEST(LegacyInterface, BadType) {
     argv.push_back("binaryname");
     argv.push_back("--port");
     argv.push_back("5");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_TRUE(environment.count("port"));
     std::string port;
     try {
@@ -2831,10 +2757,9 @@ TEST(ChainingInterface, Positional) {
     std::vector<std::string> argv;
     argv.push_back("binaryname");
     argv.push_back("positional");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::string positional;
     ASSERT_OK(value.get(&positional));
@@ -2855,10 +2780,9 @@ TEST(ChainingInterface, PositionalTooMany) {
     argv.push_back("binaryname");
     argv.push_back("positional");
     argv.push_back("extrapositional");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ChainingInterface, PositionalAndFlag) {
@@ -2877,10 +2801,9 @@ TEST(ChainingInterface, PositionalAndFlag) {
     argv.push_back("positional");
     argv.push_back("--port");
     argv.push_back("5");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::string positional;
     ASSERT_OK(value.get(&positional));
@@ -2905,9 +2828,8 @@ TEST(ChainingInterface, PositionalMultiple) {
     argv.push_back("binaryname");
     argv.push_back("positional1");
     argv.push_back("positional2");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::vector<std::string> positional;
@@ -2933,9 +2855,8 @@ TEST(ChainingInterface, PositionalMultipleExtra) {
     argv.push_back("positional1");
     argv.push_back("positional2");
     argv.push_back("positional2");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ChainingInterface, PositionalMultipleUnlimited) {
@@ -2955,9 +2876,8 @@ TEST(ChainingInterface, PositionalMultipleUnlimited) {
     argv.push_back("positional3");
     argv.push_back("positional4");
     argv.push_back("positional5");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::vector<std::string> positional;
@@ -2991,9 +2911,8 @@ TEST(ChainingInterface, PositionalMultipleAndFlag) {
     argv.push_back("--port");
     argv.push_back("5");
     argv.push_back("positional2");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("positional"), &value));
     std::vector<std::string> positional;
@@ -3040,12 +2959,11 @@ TEST(ChainingInterface, PositionalSingleMultipleUnlimitedAndFlag) {
     argv.push_back("positional7");
     argv.push_back("positional8");
     argv.push_back("positional9");
-    std::map<std::string, std::string> env_map;
 
     moe::Value value;
     std::vector<std::string>::iterator positionalit;
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("positional1"), &value));
     std::string positionalSingle;
     ASSERT_OK(value.get(&positionalSingle));
@@ -3098,9 +3016,8 @@ TEST(ChainingInterface, PositionalHoleInRange) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ChainingInterface, PositionalOverlappingRange) {
@@ -3120,9 +3037,8 @@ TEST(ChainingInterface, PositionalOverlappingRange) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ChainingInterface, PositionalOverlappingRangeInfinite) {
@@ -3142,9 +3058,8 @@ TEST(ChainingInterface, PositionalOverlappingRangeInfinite) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(ChainingInterface, PositionalMultipleInfinite) {
@@ -3164,9 +3079,8 @@ TEST(ChainingInterface, PositionalMultipleInfinite) {
 
     std::vector<std::string> argv;
     argv.push_back("binaryname");
-    std::map<std::string, std::string> env_map;
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(OptionSources, SourceCommandLine) {
@@ -3174,7 +3088,6 @@ TEST(OptionSources, SourceCommandLine) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
     std::string parameter;
 
     moe::OptionSection testOpts;
@@ -3190,7 +3103,7 @@ TEST(OptionSources, SourceCommandLine) {
     argv.push_back("--parameter");
     argv.push_back("allowed");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3202,7 +3115,7 @@ TEST(OptionSources, SourceCommandLine) {
 
     parser.setConfig("config.json", "{ parameter : \"disallowed\" }");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv.clear();
     argv.push_back("binaryname");
@@ -3211,7 +3124,7 @@ TEST(OptionSources, SourceCommandLine) {
 
     parser.setConfig("config.ini", "parameter=disallowed");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(OptionSources, SourceINIConfig) {
@@ -3219,7 +3132,6 @@ TEST(OptionSources, SourceINIConfig) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
     std::string parameter;
 
     moe::OptionSection testOpts;
@@ -3235,7 +3147,7 @@ TEST(OptionSources, SourceINIConfig) {
     argv.push_back("--parameter");
     argv.push_back("disallowed");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv.clear();
     argv.push_back("binaryname");
@@ -3244,7 +3156,7 @@ TEST(OptionSources, SourceINIConfig) {
 
     parser.setConfig("config.json", "{ parameter : \"disallowed\" }");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv.clear();
     argv.push_back("binaryname");
@@ -3253,7 +3165,7 @@ TEST(OptionSources, SourceINIConfig) {
 
     parser.setConfig("config.ini", "parameter=allowed");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3264,7 +3176,6 @@ TEST(OptionSources, SourceYAMLConfig) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
     std::string parameter;
 
     moe::OptionSection testOpts;
@@ -3280,7 +3191,7 @@ TEST(OptionSources, SourceYAMLConfig) {
     argv.push_back("--parameter");
     argv.push_back("disallowed");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv.clear();
     argv.push_back("binaryname");
@@ -3289,7 +3200,7 @@ TEST(OptionSources, SourceYAMLConfig) {
 
     parser.setConfig("config.json", "{ parameter : \"allowed\" }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3301,7 +3212,7 @@ TEST(OptionSources, SourceYAMLConfig) {
 
     parser.setConfig("config.ini", "parameter=disallowed");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(OptionSources, SourceAllConfig) {
@@ -3309,7 +3220,6 @@ TEST(OptionSources, SourceAllConfig) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
     std::string parameter;
 
     moe::OptionSection testOpts;
@@ -3325,7 +3235,7 @@ TEST(OptionSources, SourceAllConfig) {
     argv.push_back("--parameter");
     argv.push_back("disallowed");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv.clear();
     argv.push_back("binaryname");
@@ -3334,7 +3244,7 @@ TEST(OptionSources, SourceAllConfig) {
 
     parser.setConfig("config.json", "{ parameter : \"allowed\" }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3346,7 +3256,7 @@ TEST(OptionSources, SourceAllConfig) {
 
     parser.setConfig("config.ini", "parameter=allowed");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3357,7 +3267,6 @@ TEST(OptionSources, SourceAllLegacy) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
     std::string parameter;
 
     moe::OptionSection testOpts;
@@ -3373,7 +3282,7 @@ TEST(OptionSources, SourceAllLegacy) {
     argv.push_back("--parameter");
     argv.push_back("allowed");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3385,7 +3294,7 @@ TEST(OptionSources, SourceAllLegacy) {
 
     parser.setConfig("config.json", "{ parameter : \"disallowed\" }");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv.clear();
     argv.push_back("binaryname");
@@ -3394,7 +3303,7 @@ TEST(OptionSources, SourceAllLegacy) {
 
     parser.setConfig("config.ini", "parameter=allowed");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3405,7 +3314,6 @@ TEST(OptionSources, SourceAll) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
     std::string parameter;
 
     moe::OptionSection testOpts;
@@ -3421,7 +3329,7 @@ TEST(OptionSources, SourceAll) {
     argv.push_back("--parameter");
     argv.push_back("allowed");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3433,7 +3341,7 @@ TEST(OptionSources, SourceAll) {
 
     parser.setConfig("config.json", "{ parameter : \"allowed\" }");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3445,7 +3353,7 @@ TEST(OptionSources, SourceAll) {
 
     parser.setConfig("config.ini", "parameter=allowed");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("parameter"), &value));
     ASSERT_OK(value.get(&parameter));
     ASSERT_EQUALS(parameter, "allowed");
@@ -3456,7 +3364,6 @@ TEST(Constraints, MutuallyExclusiveConstraint) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
 
     moe::OptionSection testOpts;
     testOpts
@@ -3471,7 +3378,7 @@ TEST(Constraints, MutuallyExclusiveConstraint) {
     argv.push_back("--option1");
     argv.push_back("--option2");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_NOT_OK(environment.validate());
 
     environment = moe::Environment();
@@ -3479,7 +3386,7 @@ TEST(Constraints, MutuallyExclusiveConstraint) {
     argv.push_back("binaryname");
     argv.push_back("--option1");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.validate());
     ASSERT_OK(environment.get(moe::Key("option1"), &value));
 
@@ -3488,7 +3395,7 @@ TEST(Constraints, MutuallyExclusiveConstraint) {
     argv.push_back("binaryname");
     argv.push_back("--option2");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.validate());
     ASSERT_OK(environment.get(moe::Key("section.option2"), &value));
 }
@@ -3498,7 +3405,6 @@ TEST(Constraints, RequiresOtherConstraint) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
 
     moe::OptionSection testOpts;
     testOpts
@@ -3512,7 +3418,7 @@ TEST(Constraints, RequiresOtherConstraint) {
     argv.push_back("binaryname");
     argv.push_back("--option1");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_NOT_OK(environment.validate());
 
     environment = moe::Environment();
@@ -3521,7 +3427,7 @@ TEST(Constraints, RequiresOtherConstraint) {
     argv.push_back("--option1");
     argv.push_back("--option2");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.validate());
     ASSERT_OK(environment.get(moe::Key("option1"), &value));
     ASSERT_OK(environment.get(moe::Key("section.option2"), &value));
@@ -3531,7 +3437,7 @@ TEST(Constraints, RequiresOtherConstraint) {
     argv.push_back("binaryname");
     argv.push_back("--option2");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.validate());
     ASSERT_OK(environment.get(moe::Key("section.option2"), &value));
 }
@@ -3549,11 +3455,10 @@ TEST(YAMLConfigFile, Basic) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "port: 5");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -3573,11 +3478,10 @@ TEST(YAMLConfigFile, Empty) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(YAMLConfigFile, Override) {
@@ -3595,12 +3499,11 @@ TEST(YAMLConfigFile, Override) {
     argv.push_back("config.yaml");
     argv.push_back("--port");
     argv.push_back("6");
-    std::map<std::string, std::string> env_map;
 
 
     parser.setConfig("config.yaml", "port: 5");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -3620,11 +3523,10 @@ TEST(YAMLConfigFile, UnregisteredOption) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "port: 5");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(YAMLConfigFile, DuplicateOption) {
@@ -3640,11 +3542,10 @@ TEST(YAMLConfigFile, DuplicateOption) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "port: 5\nport: 5");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(YAMLConfigFile, TypeChecking) {
@@ -3687,29 +3588,28 @@ TEST(YAMLConfigFile, TypeChecking) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     // Test StringVector type
     std::vector<std::string> stringVectorVal;
 
     parser.setConfig("config.json", "stringVectorVal : \"scalar\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVectorVal : \"true\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVectorVal : \"5\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVectorVal : [ [ \"string\" ], true, 1, 1.0 ]");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a string vector type and treat it as an array of strings, even if the
     // elements are not surrounded by quotes
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVectorVal : [ \"string\", bare, true, 1, 1.0 ]");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVectorVal"), &value));
     std::vector<std::string>::iterator stringVectorValIt;
     ASSERT_OK(value.get(&stringVectorVal));
@@ -3728,25 +3628,25 @@ TEST(YAMLConfigFile, TypeChecking) {
     bool boolVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "boolVal : \"lies\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "boolVal : truth");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "boolVal : 1");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a bool type and try to convert it to a bool, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "boolVal : \"true\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("boolVal"), &value));
     ASSERT_OK(value.get(&boolVal));
     ASSERT_EQUALS(boolVal, true);
     environment = moe::Environment();
     parser.setConfig("config.json", "boolVal : false");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("boolVal"), &value));
     ASSERT_OK(value.get(&boolVal));
     ASSERT_EQUALS(boolVal, false);
@@ -3755,34 +3655,34 @@ TEST(YAMLConfigFile, TypeChecking) {
     double doubleVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "doubleVal : \"double the monkeys\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "doubleVal : true");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a double type and try to convert it to a double, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "doubleVal : 1.5");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, 1.5);
     environment = moe::Environment();
     parser.setConfig("config.json", "doubleVal : -1.5");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, -1.5);
     environment = moe::Environment();
     parser.setConfig("config.json", "doubleVal : \"3.14\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, 3.14);
     environment = moe::Environment();
     parser.setConfig("config.json", "doubleVal : \"-3.14\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
     ASSERT_EQUALS(doubleVal, -3.14);
@@ -3791,29 +3691,29 @@ TEST(YAMLConfigFile, TypeChecking) {
     int intVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "intVal : \"hungry hippos\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "intVal : 1.5");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "intVal : 18446744073709551617");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "intVal : true");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as an int type and try to convert it to a int, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "intVal : \"5\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("intVal"), &value));
     ASSERT_OK(value.get(&intVal));
     ASSERT_EQUALS(intVal, 5);
 
     environment = moe::Environment();
     parser.setConfig("config.json", "intVal : \"-5\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("intVal"), &value));
     ASSERT_OK(value.get(&intVal));
     ASSERT_EQUALS(intVal, -5);
@@ -3822,29 +3722,29 @@ TEST(YAMLConfigFile, TypeChecking) {
     long longVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "longVal : \"in an eating race\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "longVal : 1.5");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "longVal : 18446744073709551617");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "longVal : true");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a long type and try to convert it to a long, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "longVal : \"5\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("longVal"), &value));
     ASSERT_OK(value.get(&longVal));
     ASSERT_EQUALS(longVal, 5);
 
     environment = moe::Environment();
     parser.setConfig("config.json", "longVal : \"-5\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("longVal"), &value));
     ASSERT_OK(value.get(&longVal));
     ASSERT_EQUALS(longVal, -5);
@@ -3857,28 +3757,28 @@ TEST(YAMLConfigFile, TypeChecking) {
     // surrounded by quotes
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVal :");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "");
 
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVal : \"1000\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "1000");
 
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVal : wat man");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "wat man");
 
     environment = moe::Environment();
     parser.setConfig("config.json", "stringVal : true 1 string 1.0");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("stringVal"), &value));
     ASSERT_OK(value.get(&stringVal));
     ASSERT_EQUALS(stringVal, "true 1 string 1.0");
@@ -3887,26 +3787,26 @@ TEST(YAMLConfigFile, TypeChecking) {
     unsigned long long unsignedLongLongVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedLongLongVal : \"unsigned hungry hippos\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedLongLongVal : 1.5");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedLongLongVal : 18446744073709551617");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedLongLongVal : true");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedLongLongVal : \"-5\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as an unsigned long long type and try to convert it to an unsigned long long,
     // even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedLongLongVal : \"5\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("unsignedLongLongVal"), &value));
     ASSERT_OK(value.get(&unsignedLongLongVal));
     ASSERT_EQUALS(unsignedLongLongVal, 5ULL);
@@ -3915,25 +3815,25 @@ TEST(YAMLConfigFile, TypeChecking) {
     unsigned unsignedVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedVal : \"unsigned hungry hippos\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedVal : 1.5");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedVal : 18446744073709551617");  // 2^64 + 1
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedVal : true");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedVal : \"-5\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as an unsigned type and try to convert it to an unsigned, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "unsignedVal : \"5\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("unsignedVal"), &value));
     ASSERT_OK(value.get(&unsignedVal));
     ASSERT_EQUALS(unsignedVal, 5U);
@@ -3942,25 +3842,25 @@ TEST(YAMLConfigFile, TypeChecking) {
     bool switchVal;
     environment = moe::Environment();
     parser.setConfig("config.json", "switchVal : \"lies\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "switchVal : truth");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     environment = moe::Environment();
     parser.setConfig("config.json", "switchVal : 1");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // The YAML parser treats everything as a string, so we just take anything that was
     // specified as a switch type and try to convert it to a bool, even if it was quoted
     environment = moe::Environment();
     parser.setConfig("config.json", "switchVal : \"true\"");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("switchVal"), &value));
     ASSERT_OK(value.get(&switchVal));
     ASSERT_EQUALS(switchVal, true);
     environment = moe::Environment();
     parser.setConfig("config.json", "switchVal : false");
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("switchVal"), &switchVal));
     ASSERT_FALSE(switchVal);
 }
@@ -3978,11 +3878,10 @@ TEST(YAMLConfigFile, Nested) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "nested:\n    port: 5");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("nested.port"), &value));
     int port;
@@ -4003,11 +3902,10 @@ TEST(YAMLConfigFile, Dotted) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "dotted.port: 5");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("dotted.port"), &value));
     int port;
@@ -4031,11 +3929,10 @@ TEST(YAMLConfigFile, DottedAndNested) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "dottednested.var1: 5\ndottednested:\n    var2: 6");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("dottednested.var1"), &value));
     int var1;
@@ -4064,11 +3961,10 @@ TEST(YAMLConfigFile, DeprecatedDottedNameDeprecatedOnly) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "dotted.deprecated: 6");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("dotted.canonical"), &value));
     int var1;
@@ -4144,13 +4040,12 @@ TEST(YAMLConfigFile, DeprecatedDottedNameCanonicalAndDeprecated) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      "dotted.canonical: 5\n"
                      "dotted.deprecated: 6");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 // An option can have multiple deprecated dotted names.
@@ -4176,13 +4071,12 @@ TEST(YAMLConfigFile, DeprecatedDottedNameMultipleDeprecated) {
          ++i) {
         OptionsParserTester parser;
         moe::Environment environment;
-        std::map<std::string, std::string> env_map;
 
         ::mongo::StringBuilder sb;
         sb << *i << ": 6";
         parser.setConfig("config.yaml", sb.str());
 
-        ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+        ASSERT_OK(parser.run(testOpts, argv, &environment));
         moe::Value value;
         ASSERT_OK(environment.get(moe::Key("dotted.canonical"), &value));
         int var1;
@@ -4197,13 +4091,12 @@ TEST(YAMLConfigFile, DeprecatedDottedNameMultipleDeprecated) {
     {
         OptionsParserTester parser;
         moe::Environment environment;
-        std::map<std::string, std::string> env_map;
 
         std::stringstream ss;
         ss << deprecatedDottedNames[0] << ": 6" << std::endl << deprecatedDottedNames[1] << ": 7";
         parser.setConfig("config.yaml", ss.str());
 
-        ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+        ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     }
 }
 
@@ -4221,12 +4114,11 @@ TEST(YAMLConfigFile, ListBrackets) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "multival: [ \"val1\", \"val2\" ]");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::vector<std::string> multival;
     std::vector<std::string>::iterator multivalit;
@@ -4251,12 +4143,11 @@ TEST(YAMLConfigFile, ListDashes) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "multival:\n - \"val1\"\n - \"val2\"");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::vector<std::string> multival;
     std::vector<std::string>::iterator multivalit;
@@ -4281,11 +4172,10 @@ TEST(YAMLConfigFile, DefaultValueOverride) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", "port: 6");
 
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     moe::Value value;
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
@@ -4307,14 +4197,13 @@ TEST(YAMLConfigFile, Comments) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml",
                      "# comment on port\nport: 5\n"
                      "# comment on host\nhost: localhost\n");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("port"), &value));
     int port;
     ASSERT_OK(value.get(&port));
@@ -4338,11 +4227,10 @@ TEST(YAMLConfigFile, EmptyKey) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.yaml");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.yaml", ":");
 
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(YAMLConfigFile, StringVector) {
@@ -4359,12 +4247,11 @@ TEST(YAMLConfigFile, StringVector) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json", "multival : [ \"val1\", \"val2\" ]");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::vector<std::string> multival;
     std::vector<std::string>::iterator multivalit;
@@ -4389,7 +4276,6 @@ TEST(YAMLConfigFile, StringMap) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json",
                      // NOTE: Indentation is used to determine whether an option is in a sub
@@ -4398,7 +4284,7 @@ TEST(YAMLConfigFile, StringMap) {
                      "multival : \n key1 : \"value1\"\n key2 : \"value2\"\n key3 : \"\"");
 
     moe::Value value;
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
     ASSERT_OK(environment.get(moe::Key("multival"), &value));
     std::map<std::string, std::string> multival;
     std::map<std::string, std::string>::iterator multivalit;
@@ -4428,7 +4314,6 @@ TEST(YAMLConfigFile, StringMapDuplicateKey) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back("config.json");
-    std::map<std::string, std::string> env_map;
 
     parser.setConfig("config.json",
                      // NOTE: Indentation is used to determine whether an option is in a sub
@@ -4437,7 +4322,7 @@ TEST(YAMLConfigFile, StringMapDuplicateKey) {
                      "multival : \n key1 : \"value1\"\n key1 : \"value2\"");
 
     moe::Value value;
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 }
 
 TEST(OptionCount, Basic) {
@@ -4467,7 +4352,6 @@ TEST(NumericalBaseParsing, CommandLine) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
 
     moe::OptionSection testOpts;
     testOpts.addOptionChaining(
@@ -4490,31 +4374,31 @@ TEST(NumericalBaseParsing, CommandLine) {
     argv.push_back("binaryname");
     argv.push_back("--doubleVal");
     argv.push_back("monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv = std::vector<std::string>();
     argv.push_back("binaryname");
     argv.push_back("--intVal");
     argv.push_back("monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv = std::vector<std::string>();
     argv.push_back("binaryname");
     argv.push_back("--longVal");
     argv.push_back("monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv = std::vector<std::string>();
     argv.push_back("binaryname");
     argv.push_back("--unsignedLongLongVal");
     argv.push_back("monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     argv = std::vector<std::string>();
     argv.push_back("binaryname");
     argv.push_back("--unsignedVal");
     argv.push_back("monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // Decimal values
     argv = std::vector<std::string>();
@@ -4530,7 +4414,7 @@ TEST(NumericalBaseParsing, CommandLine) {
     argv.push_back("--unsignedVal");
     argv.push_back("16");
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     double doubleVal;
     int intVal;
@@ -4572,7 +4456,7 @@ TEST(NumericalBaseParsing, CommandLine) {
     argv.push_back("--unsignedVal");
     argv.push_back("020");
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
@@ -4614,7 +4498,7 @@ TEST(NumericalBaseParsing, CommandLine) {
     argv.push_back("--unsignedVal");
     argv.push_back("0x10");
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
 #if !(defined(_WIN32) || defined(__sun))
     // See SERVER-14131.
@@ -4645,7 +4529,6 @@ TEST(NumericalBaseParsing, INIConfigFile) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
 
     moe::OptionSection testOpts;
     testOpts.addOptionChaining(
@@ -4672,19 +4555,19 @@ TEST(NumericalBaseParsing, INIConfigFile) {
     argv.push_back("config.ini");
 
     parser.setConfig("config.ini", "doubleVal=monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.ini", "intVal=monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.ini", "longVal=monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.ini", "unsignedLongLongVal=monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.ini", "unsignedVal=monkeys");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // Decimal values
     argv = std::vector<std::string>();
@@ -4695,7 +4578,7 @@ TEST(NumericalBaseParsing, INIConfigFile) {
                      "doubleVal=16.1\nintVal=16\nlongVal=16\n"
                      "unsignedLongLongVal=16\nunsignedVal=16\n");
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     double doubleVal;
     int intVal;
@@ -4732,7 +4615,7 @@ TEST(NumericalBaseParsing, INIConfigFile) {
                      "doubleVal=020.1\nintVal=020\nlongVal=020\n"
                      "unsignedLongLongVal=020\nunsignedVal=020\n");
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
@@ -4773,7 +4656,7 @@ TEST(NumericalBaseParsing, INIConfigFile) {
                      "unsignedLongLongVal=0x10\nunsignedVal=0x10\n");
 #endif
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
 #if !(defined(_WIN32) || defined(__sun))
     // See SERVER-14131.
@@ -4804,7 +4687,6 @@ TEST(NumericalBaseParsing, YAMLConfigFile) {
     moe::Environment environment;
     moe::Value value;
     std::vector<std::string> argv;
-    std::map<std::string, std::string> env_map;
 
     moe::OptionSection testOpts;
     testOpts.addOptionChaining(
@@ -4831,19 +4713,19 @@ TEST(NumericalBaseParsing, YAMLConfigFile) {
     argv.push_back("config.yaml");
 
     parser.setConfig("config.yaml", "doubleVal: \"monkeys\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.yaml", "intVal: \"monkeys\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.yaml", "longVal: \"monkeys\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.yaml", "unsignedLongLongVal: \"monkeys\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     parser.setConfig("config.yaml", "unsignedVal: \"monkeys\"");
-    ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
 
     // Decimal values
     argv = std::vector<std::string>();
@@ -4854,7 +4736,7 @@ TEST(NumericalBaseParsing, YAMLConfigFile) {
                      "doubleVal: 16.1\nintVal: 16\nlongVal: 16\n"
                      "unsignedLongLongVal: 16\nunsignedVal: 16\n");
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     double doubleVal;
     int intVal;
@@ -4891,7 +4773,7 @@ TEST(NumericalBaseParsing, YAMLConfigFile) {
                      "doubleVal: 020.1\nintVal: 020\nlongVal: 020\n"
                      "unsignedLongLongVal: 020\nunsignedVal: 020\n");
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
     ASSERT_OK(environment.get(moe::Key("doubleVal"), &value));
     ASSERT_OK(value.get(&doubleVal));
@@ -4932,7 +4814,7 @@ TEST(NumericalBaseParsing, YAMLConfigFile) {
                      "unsignedLongLongVal: 0x10\nunsignedVal: 0x10\n");
 #endif
     environment = moe::Environment();
-    ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+    ASSERT_OK(parser.run(testOpts, argv, &environment));
 
 #if !(defined(_WIN32) || defined(__sun))
     // See SERVER-14131.
@@ -5000,9 +4882,8 @@ TEST(YAMLConfigFile, OutputConfig) {
         "config.yaml",
     };
 
-    std::map<std::string, std::string> env_map;
     moe::Environment env;
-    ASSERT_OK(parser.run(options, argv, env_map, &env));
+    ASSERT_OK(parser.run(options, argv, &env));
     ASSERT_EQ(env.toYAML(),
               "cacheSize: 12345\n"
               "command:\n"
@@ -5046,10 +4927,9 @@ void TestFile(std::vector<unsigned char> contents, bool valid) {
     argv.push_back("binaryname");
     argv.push_back("--config");
     argv.push_back(p.generic_string());
-    std::map<std::string, std::string> env_map;
 
     if (valid) {
-        ASSERT_OK(parser.run(testOpts, argv, env_map, &environment));
+        ASSERT_OK(parser.run(testOpts, argv, &environment));
 
         moe::Value value;
         ASSERT_OK(environment.get(moe::Key("port"), &value));
@@ -5057,7 +4937,7 @@ void TestFile(std::vector<unsigned char> contents, bool valid) {
         ASSERT_OK(value.get(&port));
         ASSERT_EQUALS(port, 1234);
     } else {
-        ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment));
+        ASSERT_NOT_OK(parser.run(testOpts, argv, &environment));
     }
 }
 
@@ -5093,8 +4973,7 @@ TEST(YAMLConfigFile, canonicalize) {
         "binary",
         "--bind_ip_all",
     };
-    std::map<std::string, std::string> env_map;
-    ASSERT_OK(parser.run(opts, argv, env_map, &env));
+    ASSERT_OK(parser.run(opts, argv, &env));
     ASSERT_TRUE(env.count("net.bindIp"));
     ASSERT_FALSE(env.count("net.bindIpAll"));
     ASSERT_EQ(env["net.bindIp"].as<std::string>(), "0.0.0.0");
diff --git a/src/mongo/util/text.cpp b/src/mongo/util/text.cpp
index dccd4d3fb49..7599b653ea8 100644
--- a/src/mongo/util/text.cpp
+++ b/src/mongo/util/text.cpp
@@ -287,55 +287,29 @@ bool writeUtf8ToWindowsConsole(const char* utf8String, unsigned int utf8StringSi
     return true;
 }
 
-WindowsCommandLine::WindowsCommandLine(int argc, wchar_t* argvW[], wchar_t* envpW[])
-    : _argv(nullptr), _envp(nullptr) {
-    // Construct UTF-8 copy of arguments
-    std::vector<std::string> utf8args;
-    std::vector<size_t> utf8argLength;
-    size_t blockSize = argc * sizeof(char*);
-    size_t blockPtr = blockSize;
-    for (int i = 0; i < argc; ++i) {
-        utf8args.push_back(toUtf8String(argvW[i]));
-        size_t argLength = utf8args[i].length() + 1;
-        utf8argLength.push_back(argLength);
-        blockSize += argLength;
-    }
-    _argv = static_cast<char**>(mongoMalloc(blockSize));
-    for (int i = 0; i < argc; ++i) {
-        _argv[i] = reinterpret_cast<char*>(_argv) + blockPtr;
-        strcpy_s(_argv[i], utf8argLength[i], utf8args[i].c_str());
-        blockPtr += utf8argLength[i];
-    }
 
-    // Construct UTF-8 copy of environment strings
-    size_t envCount = 0;
-    wchar_t** envpWptr = &envpW[0];
-    while (*envpWptr++) {
-        ++envCount;
+class WindowsCommandLine::Impl {
+public:
+    Impl(int argc, wchar_t** argvW) : _strs(argc), _argv(argc + 1) {
+        for (int i = 0; i < argc; ++i)
+            _argv[i] = (_strs[i] = toUtf8String(argvW[i])).data();
     }
-    std::vector<std::string> utf8envs;
-    std::vector<size_t> utf8envLength;
-    blockSize = (envCount + 1) * sizeof(char*);
-    blockPtr = blockSize;
-    for (size_t i = 0; i < envCount; ++i) {
-        utf8envs.push_back(toUtf8String(envpW[i]));
-        size_t envLength = utf8envs[i].length() + 1;
-        utf8envLength.push_back(envLength);
-        blockSize += envLength;
-    }
-    _envp = static_cast<char**>(mongoMalloc(blockSize));
-    size_t i;
-    for (i = 0; i < envCount; ++i) {
-        _envp[i] = reinterpret_cast<char*>(_envp) + blockPtr;
-        strcpy_s(_envp[i], utf8envLength[i], utf8envs[i].c_str());
-        blockPtr += utf8envLength[i];
+
+    char** argv() {
+        return _argv.data();
     }
-    _envp[i] = nullptr;
-}
 
-WindowsCommandLine::~WindowsCommandLine() {
-    free(_argv);
-    free(_envp);
+    std::vector<std::string> _strs;  // utf8 encoded
+    std::vector<char*> _argv;        // [_strs..., nullptr]
+};
+
+WindowsCommandLine::WindowsCommandLine(int argc, wchar_t** argvW)
+    : _impl{std::make_unique<Impl>(argc, argvW)} {}
+
+WindowsCommandLine::~WindowsCommandLine() = default;
+
+char** WindowsCommandLine::argv() const {
+    return _impl->argv();
 }
 
 #endif  // #if defined(_WIN32)
diff --git a/src/mongo/util/text.h b/src/mongo/util/text.h
index 40493fa9d4f..e189194f538 100644
--- a/src/mongo/util/text.h
+++ b/src/mongo/util/text.h
@@ -93,20 +93,15 @@ inline std::wstring toNativeString(const char* s) {
 #endif
 
 class WindowsCommandLine {
-    WindowsCommandLine(const WindowsCommandLine&) = delete;
-    WindowsCommandLine& operator=(const WindowsCommandLine&) = delete;
-    char** _argv;
-    char** _envp;
-
 public:
-    WindowsCommandLine(int argc, wchar_t* argvW[], wchar_t* envpW[]);
+    WindowsCommandLine(int argc, wchar_t** argvW);
     ~WindowsCommandLine();
-    char** argv(void) const {
-        return _argv;
-    };
-    char** envp(void) const {
-        return _envp;
-    };
+
+    char** argv() const;
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> _impl;
 };
 
 #endif  // #if defined(_WIN32)