goopdate/command_line_unittest.cc

// Copyright 2007-2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================

#include "omaha/common/error.h"
#include "omaha/common/string.h"
#include "omaha/common/utils.h"
#include "omaha/goopdate/command_line.h"
#include "omaha/goopdate/command_line_builder.h"
#include "omaha/goopdate/const_goopdate.h"
#include "omaha/goopdate/goopdate_utils.h"
#include "omaha/net/http_client.h"
#include "omaha/testing/resource.h"
#include "omaha/testing/unit_test.h"

namespace omaha {

// Used by extra_args_parser_unittest.cc.
void VerifyCommandLineExtraArgs(const CommandLineExtraArgs& expected_val,
                                const CommandLineExtraArgs& actual_val);

namespace {

#define YOUTUBEUPLOADEREN_TAG_WITHOUT_QUOTES \
    _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&") \
    _T("appname=YouTubeUploader&needsadmin=False&lang=en")

#define YOUTUBEUPLOADEREN_APP_ARGS_WITHOUT_QUOTES \
    _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&") \
    _T("installerdata=YouTube%20Uploader%20Data")

#define YOUTUBEUPLOADEREN_TAG \
    _T("\"") YOUTUBEUPLOADEREN_TAG_WITHOUT_QUOTES _T("\"")

#define YOUTUBEUPLOADEREN_APP_ARGS \
    _T("\"") YOUTUBEUPLOADEREN_APP_ARGS_WITHOUT_QUOTES _T("\"")

void VerifyCommandLineArgs(const CommandLineArgs& expected,
                           const CommandLineArgs& actual) {
  EXPECT_EQ(expected.mode, actual.mode);

  EXPECT_EQ(expected.is_interactive_set, actual.is_interactive_set);
  EXPECT_EQ(expected.is_machine_set, actual.is_machine_set);
  EXPECT_EQ(expected.is_install_elevated, actual.is_install_elevated);
  EXPECT_EQ(expected.is_silent_set, actual.is_silent_set);
  EXPECT_EQ(expected.is_eula_required_set, actual.is_eula_required_set);
  EXPECT_EQ(expected.is_offline_set, actual.is_offline_set);
  EXPECT_EQ(expected.is_oem_set, actual.is_oem_set);
  EXPECT_EQ(expected.is_uninstall_set, actual.is_uninstall_set);

  EXPECT_STREQ(expected.extra_args_str, actual.extra_args_str);
  EXPECT_STREQ(expected.app_args_str, actual.app_args_str);
  EXPECT_STREQ(expected.install_source, actual.install_source);
  EXPECT_STREQ(expected.crash_filename, actual.crash_filename);
  EXPECT_STREQ(expected.custom_info_filename, actual.custom_info_filename);
  EXPECT_STREQ(expected.legacy_manifest_path, actual.legacy_manifest_path);
  EXPECT_STREQ(expected.webplugin_urldomain, actual.webplugin_urldomain);
  EXPECT_STREQ(expected.webplugin_args, actual.webplugin_args);
  EXPECT_STREQ(expected.code_red_metainstaller_path,
               actual.code_red_metainstaller_path);

  VerifyCommandLineExtraArgs(expected.extra, actual.extra);
}

void VerifyArgsWithSingleYouTubeUploaderEnApp(
    const CommandLineArgs& expected_without_app,
    const CommandLineArgs& actual,
    bool expect_app_args,
    bool expect_language) {
  CommandLineArgs expected(expected_without_app);

  const GUID expected_guid = {0xA4F7B07B, 0xB9BD, 0x4A33,
                              {0xB1, 0x36, 0x96, 0xD2, 0xAD, 0xFB, 0x60, 0xCB}};
  CommandLineAppArgs app_args;
  app_args.app_guid = expected_guid;
  app_args.app_name = _T("YouTubeUploader");
  app_args.needs_admin = false;
  if (expected.extra_args_str.IsEmpty()) {
    expected.extra_args_str = YOUTUBEUPLOADEREN_TAG_WITHOUT_QUOTES;
  }
  if (expect_language) {
    expected.extra.language = _T("en");
  }
  if (expect_app_args) {
    expected.app_args_str =
        YOUTUBEUPLOADEREN_APP_ARGS_WITHOUT_QUOTES;
    app_args.encoded_installer_data = _T("YouTube%20Uploader%20Data");
  }

  expected.extra.apps.push_back(app_args);
  VerifyCommandLineArgs(expected, actual);
}

}  // namespace

void VerifyCommandLineExtraArgs(const CommandLineExtraArgs& expected_val,
                                const CommandLineExtraArgs& actual_val) {
  EXPECT_EQ(expected_val.apps.size(), actual_val.apps.size());

  EXPECT_STREQ(GuidToString(expected_val.installation_id),
               GuidToString(actual_val.installation_id));
  EXPECT_STREQ(expected_val.brand_code, actual_val.brand_code);
  EXPECT_STREQ(expected_val.client_id, actual_val.client_id);
  EXPECT_STREQ(expected_val.referral_id, actual_val.referral_id);
  EXPECT_EQ(expected_val.browser_type, actual_val.browser_type);
  EXPECT_EQ(expected_val.usage_stats_enable, actual_val.usage_stats_enable);
  EXPECT_STREQ(expected_val.language, actual_val.language);

  for (size_t i = 0; i < actual_val.apps.size(); ++i) {
    CommandLineAppArgs expected = expected_val.apps[i];
    CommandLineAppArgs actual = actual_val.apps[i];

    EXPECT_STREQ(GuidToString(expected.app_guid),
                 GuidToString(actual.app_guid));
    EXPECT_STREQ(expected.app_name, actual.app_name);
    EXPECT_EQ(expected.needs_admin, actual.needs_admin);
    EXPECT_STREQ(expected.ap, actual.ap);
    EXPECT_STREQ(expected.tt_token, actual.tt_token);
    EXPECT_STREQ(expected.encoded_installer_data,
                 actual.encoded_installer_data);
    EXPECT_STREQ(expected.install_data_index, actual.install_data_index);
  }
}

class CommandLineTest : public testing::Test {
 protected:
  CommandLineArgs args_;
  CommandLineArgs expected_;
};

TEST(CommandLineSimpleTest, GetCmdLineTail1) {
  EXPECT_STREQ(_T(""),  GetCmdLineTail(_T("")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail2) {
  EXPECT_STREQ(_T(""), GetCmdLineTail(_T("a")));
}
TEST(CommandLineSimpleTest, GetCmdLineTail3) {
  EXPECT_STREQ(_T(""), GetCmdLineTail(_T("goopdate.exe")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail4) {
  // Double quotes.
  EXPECT_STREQ(_T(""), GetCmdLineTail(_T("\"Google Update.exe\"")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail5) {
  // Argument.
  EXPECT_STREQ(_T("foobar"), GetCmdLineTail(_T("goopdate.exe foobar")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail6) {
  // Double quotes and argument.
  EXPECT_STREQ(_T("foobar"),
               GetCmdLineTail(_T("\"Google Update.exe\" foobar")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail7) {
  // Double quotes and inner double quote and argument.
  EXPECT_STREQ(_T("foobar"),
               GetCmdLineTail(_T("\"Google\"\" Update.exe\" foobar")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail8) {
  // Double quotes and two arguments.
  EXPECT_STREQ(_T("foo bar"),
               GetCmdLineTail(_T("\"Google Update.exe\" foo bar")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail9) {
  // Double quotes and one argument with quotes.
  EXPECT_STREQ(_T("\"foo bar\""),
               GetCmdLineTail(_T("\"Google Update.exe\" \"foo bar\"")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail10) {
  // \t as white space.
  EXPECT_STREQ(_T("foo bar"),
               GetCmdLineTail(_T("\"Google Update.exe\"\tfoo bar")));
}

TEST(CommandLineSimpleTest, GetCmdLineTail11) {
  // Trailing space.
  EXPECT_STREQ(_T("foo bar "),
               GetCmdLineTail(_T("\"Google Update.exe\" foo bar ")));
}

//
// This block contains the positive test cases for each of the command lines.
// If you add a new command line parameter permutation, add a test case here.
//

// TODO(omaha): Add some negative failure cases to the command lines (like
// /install without "extraargs").

// TODO(omaha): This is an Omaha1 back-compat issue.  Omaha2 should _never_
// call googleupdate.exe with no arguments.  So when we stop supporting Omaha1
// handoffs we should remove this support.
  // Parse empty command line.
TEST_F(CommandLineTest, ParseCommandLine_Empty) {
  const TCHAR* kCmdLine = _T("");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_NOARGS;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path>
// Remember that by convention the OS is passing us the program executable
// name as the first token in the command line and the parsing code skips that.
TEST_F(CommandLineTest, ParseCommandLine_ProgramNameOnly) {
  const TCHAR* kCmdLine = _T("goopdate.exe");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_NOARGS;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /svc
TEST_F(CommandLineTest, ParseCommandLine_Svc) {
  const TCHAR* kCmdLine = _T("\"C:\\Program Files\\Google\\Common\\Update\\")
                           _T("1.0.18.0\\goopdate.exe\" /svc");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_SERVICE;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> -Embedding. The -Embedding text is injected via COM.
TEST_F(CommandLineTest, ParseCommandLine_Server) {
  const TCHAR* kCmdLine = _T("goopdate.exe -Embedding");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_COMSERVER;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /install "extraargs"
TEST_F(CommandLineTest, ParseCommandLine_Install) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /install ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False&")
      _T("appguid={C7A9A2F5-C4F9-42d3-8A8B-55086A205468}&")
      _T("appname=TestApp&needsadmin=true&lang=en\"");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;

  expected_.extra_args_str = _T("appguid=")
                            _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
                            _T("appname=YouTubeUploader&needsadmin=False&")
                            _T("appguid=")
                            _T("{C7A9A2F5-C4F9-42d3-8A8B-55086A205468}&")
                            _T("appname=TestApp&needsadmin=true&lang=en");
  CommandLineAppArgs app_args;
  const GUID expected_guid = {0xA4F7B07B, 0xB9BD, 0x4A33,
                              {0xB1, 0x36, 0x96, 0xD2, 0xAD, 0xFB, 0x60, 0xCB}};
  app_args.app_guid = expected_guid;
  app_args.app_name = _T("YouTubeUploader");
  app_args.needs_admin = false;
  expected_.extra.apps.push_back(app_args);

  CommandLineAppArgs app_args1;
  app_args1.app_guid =
      StringToGuid(_T("{C7A9A2F5-C4F9-42d3-8A8B-55086A205468}"));
  app_args1.app_name = _T("TestApp");
  app_args1.needs_admin = true;
  expected_.extra.apps.push_back(app_args1);
  expected_.extra.language = _T("en");

  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /install "extraargs" /oem
TEST_F(CommandLineTest, ParseCommandLine_InstallWithOem) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /oem");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_oem_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" [/oem
// This tests how we handle a switch with a bracket, which represents optional
// parameters in a rule, when it appears in an actual command line.
TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemIgnored) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" [/oem");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_oem_set = false;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /appargs <appargs>
TEST_F(CommandLineTest, ParseCommandLine_InstallWithAppArgs) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS;
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /install "extraargs" /oem /appargs <appargs>
TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemAppArgs) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /oem")
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS;
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_oem_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /install "extraargs" /appargs <appargs> /silent
TEST_F(CommandLineTest, ParseCommandLine_InstallWithAppArgsSilent) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /install "extraargs" /oem /appargs <appargs> /silent
TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemAppArgsSilent) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /oem")
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_oem_set = true;
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse:
//  <path> /install "extraargs" /oem /appargs <appargs> /silent /eularequired
TEST_F(CommandLineTest,
       ParseCommandLine_InstallWithOemAppArgsSilentEulaRequired) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
      _T(" /oem")
      _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
      _T(" /silent")
      _T(" /eularequired");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_oem_set = true;
  expected_.is_silent_set = true;
  expected_.is_eula_required_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /install "extraargs" /eularequired
TEST_F(CommandLineTest, ParseCommandLine_InstallEulaRequired) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
      _T(" /eularequired");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_eula_required_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /oem /installsource oneclick
TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemAndSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /oem")
                          _T(" /installsource oneclick");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_oem_set = true;
  expected_.install_source = _T("oneclick");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /installsource oneclick
TEST_F(CommandLineTest, ParseCommandLine_InstallWithSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource oneclick");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.install_source = _T("oneclick");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /silent
TEST_F(CommandLineTest, ParseCommandLine_InstallSilent) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /silent /oem
TEST_F(CommandLineTest, ParseCommandLine_InstallSilentWithOem) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /silent")
                          _T(" /oem");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_silent_set = true;
  expected_.is_oem_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /installsource oneclick /silent
TEST_F(CommandLineTest, ParseCommandLine_InstallSilentWithSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource oneclick")
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.install_source = _T("oneclick");
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /installelevated
TEST_F(CommandLineTest, ParseCommandLine_InstallElevated) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installelevated");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_install_elevated = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /installelevated /installsource oneclick
TEST_F(CommandLineTest, ParseCommandLine_InstallElevatedWithSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installelevated /installsource oneclick");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.is_install_elevated = true;
  expected_.install_source = _T("oneclick");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs"
TEST_F(CommandLineTest, ParseCommandLine_Ig) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG;
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /offlineinstall
// While legal, this command line is not supported.
TEST_F(CommandLineTest, ParseCommandLine_IgOfflineWithoutInstallSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /installsource oneclick
TEST_F(CommandLineTest, ParseCommandLine_IgWithSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource oneclick");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.install_source = _T("oneclick");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /installsource offline /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_IgWithSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource offline /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.install_source = _T("offline");
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /appargs <appargs>
//               /installsource offline /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_IgWithAppArgsSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /installsource offline /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.install_source = _T("offline");
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /ig "extraargs" /silent
TEST_F(CommandLineTest, ParseCommandLine_IgSilent) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /silent");

  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /silent /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_IgSilentOfflineWithoutInstallSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /silent")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /installsource oneclick /silent
TEST_F(CommandLineTest, ParseCommandLine_IgSilentWithSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource oneclick")
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.install_source = _T("oneclick");
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /installsource oneclick /silent /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_IgSilentWithSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource oneclick")
                          _T(" /silent")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.install_source = _T("oneclick");
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ig "extraargs" /appargs <appargs>
TEST_F(CommandLineTest, ParseCommandLine_IgWithAppArgs) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS;
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /ig "extraargs" /appargs <appargs> /silent
TEST_F(CommandLineTest, ParseCommandLine_IgSilentWithAppArgs) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /ig "extraargs" /appargs <appargs> /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_IgWithAppArgsOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /ig "extraargs" /appargs <appargs> /silent /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_IgSilentWithAppArgsOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /silent")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /ig "extraargs" /appargs <appargs>
//               /installsource offline /silent /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_IgSilentWithAppArgsSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /installsource offline")
                          _T(" /silent")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.install_source = _T("offline");
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /ig "extraargs" /appargs <appargs>
//               /installsource offline /silent /offlineinstall /eularequired
TEST_F(CommandLineTest,
       ParseCommandLine_IgSilentWithAppArgsSourceOfflineEulaRequired) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /installsource offline")
                          _T(" /silent")
                          _T(" /offlineinstall")
                          _T(" /eularequired");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.install_source = _T("offline");
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  expected_.is_eula_required_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /ig "extraargs" /eularequired
TEST_F(CommandLineTest, ParseCommandLine_IgEulaRequired) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG
                          _T(" /eularequired");

  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_IG;
  expected_.is_eula_required_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs"
TEST_F(CommandLineTest, ParseCommandLine_Handoff) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG;
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_HandoffOfflineWithoutInstallSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /installsource "asd"
TEST_F(CommandLineTest, ParseCommandLine_HandoffWithSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource oneclick");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("oneclick");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /installsource offline /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_HandoffWithSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource offline")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("offline");
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /appargs <appargs>
//               /installsource offline /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_HandoffWithAppArgsSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /installsource offline /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("offline");
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /handoff "extraargs" /silent
TEST_F(CommandLineTest, ParseCommandLine_HandoffSilent) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /silent /offlineinstall
TEST_F(CommandLineTest,
       ParseCommandLine_HandoffSilentOfflineWithoutInstallSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /silent")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /installsource "asd" /silent
TEST_F(CommandLineTest, ParseCommandLine_HandoffSilentWithSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource oneclick")
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("oneclick");
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse:
//   <path> /handoff "extraargs" /installsource offline /silent /offlineinstall
TEST_F(CommandLineTest, ParseCommandLine_HandoffSilentWithSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /installsource offline")
                          _T(" /silent")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("offline");
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /appargs <appargs>
TEST_F(CommandLineTest, ParseCommandLine_HandoffWithAppArgs) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS;
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /handoff "extraargs" /appargs <appargs> /silent
TEST_F(CommandLineTest, ParseCommandLine_HandoffSilentWithAppArgs) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /silent");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.is_silent_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /handoff "extraargs" /appargs <appargs>
//               /installsource offline /silent /offlineinstall
TEST_F(CommandLineTest,
       ParseCommandLine_HandoffSilentWithAppArgsSourceOffline) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /installsource offline")
                          _T(" /silent")
                          _T(" /offlineinstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("offline");
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /handoff "extraargs" /appargs <appargs>
//               /installsource offline /silent /offlineinstall /eularequired
TEST_F(CommandLineTest,
       ParseCommandLine_HandoffSilentWithAppArgsSourceOfflineEulaRequired) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
                          _T(" /installsource offline")
                          _T(" /silent")
                          _T(" /offlineinstall")
                          _T(" /eularequired");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("offline");
  expected_.is_silent_set = true;
  expected_.is_offline_set = true;
  expected_.is_eula_required_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
}

// Parse: <path> /handoff "extraargs" /eularequired
TEST_F(CommandLineTest, ParseCommandLine_HandoffEulaRequired) {
  const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
                          _T(" /eularequired");

  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.is_eula_required_set = true;
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /ug
TEST_F(CommandLineTest, ParseCommandLine_Ug) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ug");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_UG;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /ua
TEST_F(CommandLineTest, ParseCommandLine_UaNoInstallSource) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ua");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_UA;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /ua /installsource core
TEST_F(CommandLineTest, ParseCommandLine_Ua) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ua /installsource core");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_UA;
  expected_.install_source = _T("core");
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /ua /installsource core /uninstall
TEST_F(CommandLineTest, ParseCommandLine_UaWithUninstall) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ua /installsource core /uninstall");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_UA;
  expected_.install_source = _T("core");
  expected_.is_uninstall_set = true;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /update
TEST_F(CommandLineTest, ParseCommandLine_Update) {
  const TCHAR* kCmdLine = _T("goopdate.exe /update");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_UPDATE;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /netdiags
TEST_F(CommandLineTest, ParseCommandLine_NetDiags) {
  const TCHAR* kCmdLine = _T("goopdate.exe /netdiags");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_NETDIAGS;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /regserver
TEST_F(CommandLineTest, ParseCommandLine_Regserver) {
  const TCHAR* kCmdLine = _T("goopdate.exe /regserver");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_REGSERVER;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /unregserver
TEST_F(CommandLineTest, ParseCommandLine_Unregserver) {
  const TCHAR* kCmdLine = _T("goopdate.exe /unregserver");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_UNREGSERVER;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /registerproduct
TEST_F(CommandLineTest, ParseCommandLine_RegisterProduct) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /registerproduct ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False\"");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_REGISTER_PRODUCT;
  expected_.extra_args_str = _T("appguid=")
                            _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
                            _T("appname=YouTubeUploader&needsadmin=False");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, false);
}

// Parse: <path> /registerproduct /installsource enterprisemsi
TEST_F(CommandLineTest, ParseCommandLine_RegisterProductWithInstallSource) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /registerproduct ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False\"")
      _T(" /installsource enterprisemsi");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
  expected_.mode = COMMANDLINE_MODE_REGISTER_PRODUCT;
  expected_.install_source = _T("enterprisemsi");
  expected_.extra_args_str = _T("appguid=")
                            _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
                            _T("appname=YouTubeUploader&needsadmin=False");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, false);
}

// Parse: <path> /unregisterproduct
TEST_F(CommandLineTest, ParseCommandLine_UnregisterProduct) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /unregisterproduct ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False\"");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_UNREGISTER_PRODUCT;
  expected_.extra_args_str = _T("appguid=")
                            _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
                            _T("appname=YouTubeUploader&needsadmin=False");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, false);
}

// Parse: <path> /c
TEST_F(CommandLineTest, ParseCommandLine_Core) {
  const TCHAR* kCmdLine = _T("goopdate.exe /c");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_CORE;
  expected_.is_crash_handler_disabled = false;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /c /nocrashserver
TEST_F(CommandLineTest, ParseCommandLine_CoreNoCrashHandler) {
  const TCHAR* kCmdLine = _T("goopdate.exe /c /nocrashserver");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_CORE;
  expected_.is_crash_handler_disabled = true;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /crash
TEST_F(CommandLineTest, ParseCommandLine_Crash) {
  const TCHAR* kCmdLine = _T("goopdate.exe /crash");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_CRASH;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /report crash_file
TEST_F(CommandLineTest, ParseCommandLine_Report) {
  const TCHAR* kCmdLine = _T("goopdate.exe /report C:\\foo\\crash.dmp");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
  expected_.crash_filename = _T("C:\\foo\\crash.dmp");
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /report crash_file /machine
TEST_F(CommandLineTest, ParseCommandLine_ReportMachine) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /report C:\\foo\\crash.dmp /machine");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
  expected_.crash_filename = _T("C:\\foo\\crash.dmp");
  expected_.is_machine_set = true;
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /report crash_file
TEST_F(CommandLineTest, ParseCommandLine_ReportWithCustomInfo) {
  const TCHAR* kCmdLine =
    _T("goopdate.exe /report C:\\foo.dmp /custom_info_filename C:\\foo.txt");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
  expected_.crash_filename = _T("C:\\foo.dmp");
  expected_.custom_info_filename = _T("C:\\foo.txt");
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /report /i crash_file
TEST_F(CommandLineTest, ParseCommandLine_ReportInteractive) {
  const TCHAR* kCmdLine = _T("goopdate.exe /report /i C:\\foo\\crash.dmp");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
  expected_.is_interactive_set = true;
  expected_.crash_filename = _T("C:\\foo\\crash.dmp");
  VerifyCommandLineArgs(expected_, args_);
}

// Parse: <path> /report /i crash_file /machine
TEST_F(CommandLineTest, ParseCommandLine_ReportMachineInteractive) {
  const TCHAR*
      kCmdLine = _T("goopdate.exe /report /i C:\\foo\\crash.dmp /machine");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
  expected_.is_machine_set = true;
  expected_.is_interactive_set = true;
  expected_.crash_filename = _T("C:\\foo\\crash.dmp");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_CodeRedCheck) {
  const TCHAR* kCmdLine = _T("goopdate.exe /cr");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_CODE_RED_CHECK;
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_WebPlugin) {
  const TCHAR* kCmdLine = _T("goopdate.exe /pi \"http://gears.google.com/\" ")
                          _T("\"/install foo\" /installsource oneclick ");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_WEBPLUGIN;
  expected_.webplugin_urldomain = _T("http://gears.google.com/");
  expected_.webplugin_args = _T("/install foo");
  expected_.install_source = _T("oneclick");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_WebPluginUrlEscaped) {
  const TCHAR* kCmdLine = _T("goopdate.exe /pi \"http://gears.google.com/\" ")
                          _T("\"/install%20foo\" /installsource oneclick ");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_WEBPLUGIN;
  expected_.webplugin_urldomain = _T("http://gears.google.com/");
  expected_.webplugin_args = _T("/install foo");
  expected_.install_source = _T("oneclick");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_WebPluginTestStringTrim) {
  const TCHAR* kCmdLine = _T("goopdate.exe /pi ")
                          _T("\"  http://gears.google.com/   \"  ")
                          _T("\"/install foo\" /installsource oneclick ");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_WEBPLUGIN;
  expected_.webplugin_urldomain = _T("http://gears.google.com/");
  expected_.webplugin_args = _T("/install foo");
  expected_.install_source = _T("oneclick");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_UiNoLanguage) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ui \"manifestfilename.xml\"");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_LEGACYUI;
  expected_.legacy_manifest_path = _T("manifestfilename.xml");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_UiWithLanguage) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /ui /lang fr \"manifestfilename.xml\"");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_LEGACYUI;
  expected_.legacy_manifest_path = _T("manifestfilename.xml");
  expected_.extra.language = _T("fr");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_UiUser) {
  const TCHAR* kCmdLine = _T("goopdate.exe /uiuser file.gup");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_LEGACY_MANIFEST_HANDOFF;
  expected_.legacy_manifest_path = _T("file.gup");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_Recover) {
  const TCHAR* kCmdLine = _T("goopdate.exe /recover repairfile.exe");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_RECOVER;
  expected_.code_red_metainstaller_path = _T("repairfile.exe");
  VerifyCommandLineArgs(expected_, args_);
}

TEST_F(CommandLineTest, ParseCommandLine_RecoverMachine) {
  const TCHAR* kCmdLine = _T("goopdate.exe /recover /machine repfile.exe");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_RECOVER;
  expected_.is_machine_set = true;
  expected_.code_red_metainstaller_path = _T("repfile.exe");
  VerifyCommandLineArgs(expected_, args_);
}

//
// These are additional failure cases against the command line parsing.
// Everything from here on down should fail ParseCommandLine().
//


// Parse: <path> manifest_file
TEST_F(CommandLineTest, ParseCommandLine_GoopdateJustArg) {
  const TCHAR* kCmdLine = _T("goopdate.exe \"foo bar\"");
  ExpectAsserts expect_asserts;
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

// Parse: <path> /install manifest_file manifest_file
// Fails since this is an invalid command line set.
TEST_F(CommandLineTest, ParseCommandLine_Invalid) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install \"foo bar\" foobar");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

// Parse: <path> /recover
TEST_F(CommandLineTest, Recover_WithoutFile) {
  const TCHAR* kCmdLine = _T("goopdate.exe /recover");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

// Parse: <path> /machine
TEST_F(CommandLineTest, MachineWithoutRecover) {
  const TCHAR* kCmdLine = _T("goopdate.exe /machine");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

TEST_F(CommandLineTest, ExtraArgsHasDoubleQuoteInTheMiddle) {
  const TCHAR* kCmdLine = _T("goopdate.exe /install \"some_\"file\"");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

TEST_F(CommandLineTest, CommandsNotSeparatedBySpaces) {
  const TCHAR* kCmdLine = _T("goopdate.exe /recover/machine");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

TEST_F(CommandLineTest, CommandsDoNotHaveForwardSlashes) {
  const TCHAR* kCmdLine = _T("goopdate.exe recover machine");
  ExpectAsserts expect_asserts;
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

TEST_F(CommandLineTest, UnknownParameter) {
  const TCHAR* kCmdLine = _T("goopdate.exe /someunknowncommand");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

TEST_F(CommandLineTest, UiWithLangNoLanguage) {
  const TCHAR* kCmdLine = _T("goopdate.exe /ui /lang \"manifestfilename.xml\"");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

TEST_F(CommandLineTest, WebPluginInstallSourceInvalid_IncorrectValue) {
  const TCHAR* kCmdLine = _T("goopdate.exe /installsource invalid /pi ")
                          _T("\"  http://gears.google.com/   \"  ");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

TEST_F(CommandLineTest, WebPluginInstallSourceInvalid_Empty) {
  const TCHAR* kCmdLine = _T("goopdate.exe /installsource /pi ")
                          _T("\"  http://gears.google.com/   \"  ");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

// Parse: <path> /handoff "extraargs" /lang "en"
TEST_F(CommandLineTest, ParseCommandLine_HandoffLegacy) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /handoff ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False\"")
      _T(" /lang en");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.extra_args_str =
      _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /installsource "asd" /lang "en"
TEST_F(CommandLineTest, ParseCommandLine_HandoffWithSourceLegacy) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /handoff ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False\"")
      _T(" /installsource oneclick /lang en");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("oneclick");
  expected_.extra_args_str =
      _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /handoff "extraargs" /installsource "oneclick" /lang "en"
TEST_F(CommandLineTest, ParseCommandLine_HandoffWithSourceLegacyBoth) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /handoff ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False&lang=en\"")
      _T(" /installsource oneclick /lang en");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
  expected_.install_source = _T("oneclick");
  expected_.extra_args_str =
      _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False&lang=en");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

// Parse: <path> /install "extraargs" /lang en
TEST_F(CommandLineTest, ParseCommandLine_InstallLegacy) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /install ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False&")
      _T("appguid={C7A9A2F5-C4F9-42d3-8A8B-55086A205468}&")
      _T("appname=TestApp&needsadmin=true\" /lang en");
  EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
}

// Parse: <path> /install "extraargs" /installsource oneclick /lang en
TEST_F(CommandLineTest, ParseCommandLine_InstallWithSourceLegacy) {
  const TCHAR* kCmdLine =
      _T("goopdate.exe /install ")
      _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False\"")
      _T(" /installsource oneclick /lang en");
  EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));

  expected_.mode = COMMANDLINE_MODE_INSTALL;
  expected_.install_source = _T("oneclick");
  expected_.extra_args_str =
      _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
      _T("appname=YouTubeUploader&needsadmin=False");
  VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
}

}  // namespace omaha