Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(166)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: common/command_line_unittest.cc

Issue 624713003: Keep only base/extractor.[cc|h]. (Closed) Base URL: https://chromium.googlesource.com/external/omaha.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « common/command_line_builder_unittest.cc ('k') | common/config_manager.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2007-2009 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 // ========================================================================
15
16 #include "omaha/base/utils.h"
17 #include "omaha/common/command_line.h"
18 #include "omaha/testing/unit_test.h"
19
20 namespace omaha {
21
22 // Used by extra_args_parser_unittest.cc.
23 void VerifyCommandLineExtraArgs(const CommandLineExtraArgs& expected_val,
24 const CommandLineExtraArgs& actual_val);
25
26 namespace {
27
28 #define YOUTUBEUPLOADEREN_TAG_WITHOUT_QUOTES \
29 _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&") \
30 _T("appname=YouTubeUploader&needsadmin=False&lang=en")
31
32 #define YOUTUBEUPLOADEREN_APP_ARGS_WITHOUT_QUOTES \
33 _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&") \
34 _T("installerdata=YouTube%20Uploader%20Data")
35
36 #define YOUTUBEUPLOADEREN_TAG \
37 _T("\"") YOUTUBEUPLOADEREN_TAG_WITHOUT_QUOTES _T("\"")
38
39 #define YOUTUBEUPLOADEREN_APP_ARGS \
40 _T("\"") YOUTUBEUPLOADEREN_APP_ARGS_WITHOUT_QUOTES _T("\"")
41
42 void VerifyCommandLineArgs(const CommandLineArgs& expected,
43 const CommandLineArgs& actual) {
44 EXPECT_EQ(expected.mode, actual.mode);
45
46 EXPECT_EQ(expected.is_interactive_set, actual.is_interactive_set);
47 EXPECT_EQ(expected.is_machine_set, actual.is_machine_set);
48 EXPECT_EQ(expected.is_install_elevated, actual.is_install_elevated);
49 EXPECT_EQ(expected.is_silent_set, actual.is_silent_set);
50 EXPECT_EQ(expected.is_eula_required_set, actual.is_eula_required_set);
51 EXPECT_EQ(expected.is_offline_set, actual.is_offline_set);
52 EXPECT_EQ(expected.is_oem_set, actual.is_oem_set);
53
54 EXPECT_STREQ(expected.extra_args_str, actual.extra_args_str);
55 EXPECT_STREQ(expected.app_args_str, actual.app_args_str);
56 EXPECT_STREQ(expected.install_source, actual.install_source);
57 EXPECT_STREQ(expected.crash_filename, actual.crash_filename);
58 EXPECT_STREQ(expected.custom_info_filename, actual.custom_info_filename);
59 EXPECT_STREQ(expected.legacy_manifest_path, actual.legacy_manifest_path);
60 EXPECT_STREQ(expected.webplugin_urldomain, actual.webplugin_urldomain);
61 EXPECT_STREQ(expected.webplugin_args, actual.webplugin_args);
62 EXPECT_STREQ(expected.code_red_metainstaller_path,
63 actual.code_red_metainstaller_path);
64 EXPECT_STREQ(expected.offline_dir, actual.offline_dir);
65
66 VerifyCommandLineExtraArgs(expected.extra, actual.extra);
67 }
68
69 void VerifyArgsWithSingleYouTubeUploaderEnApp(
70 const CommandLineArgs& expected_without_app,
71 const CommandLineArgs& actual,
72 bool expect_app_args,
73 bool expect_language) {
74 CommandLineArgs expected(expected_without_app);
75
76 const GUID expected_guid = {0xA4F7B07B, 0xB9BD, 0x4A33,
77 {0xB1, 0x36, 0x96, 0xD2, 0xAD, 0xFB, 0x60, 0xCB}};
78 CommandLineAppArgs app_args;
79 app_args.app_guid = expected_guid;
80 app_args.app_name = _T("YouTubeUploader");
81 app_args.needs_admin = NEEDS_ADMIN_NO;
82 if (expected.extra_args_str.IsEmpty()) {
83 expected.extra_args_str = YOUTUBEUPLOADEREN_TAG_WITHOUT_QUOTES;
84 }
85 if (expect_language) {
86 expected.extra.language = _T("en");
87 }
88 if (expect_app_args) {
89 expected.app_args_str =
90 YOUTUBEUPLOADEREN_APP_ARGS_WITHOUT_QUOTES;
91 app_args.encoded_installer_data = _T("YouTube%20Uploader%20Data");
92 }
93
94 expected.extra.apps.push_back(app_args);
95 expected.extra.bundle_name = _T("YouTubeUploader");
96 VerifyCommandLineArgs(expected, actual);
97 }
98
99 } // namespace
100
101 void VerifyCommandLineExtraArgs(const CommandLineExtraArgs& expected_val,
102 const CommandLineExtraArgs& actual_val) {
103 EXPECT_STREQ(expected_val.bundle_name, actual_val.bundle_name);
104 EXPECT_STREQ(GuidToString(expected_val.installation_id),
105 GuidToString(actual_val.installation_id));
106 EXPECT_STREQ(expected_val.brand_code, actual_val.brand_code);
107 EXPECT_STREQ(expected_val.client_id, actual_val.client_id);
108 EXPECT_STREQ(expected_val.experiment_labels,
109 actual_val.experiment_labels);
110 EXPECT_STREQ(expected_val.referral_id, actual_val.referral_id);
111 EXPECT_STREQ(expected_val.language, actual_val.language);
112 EXPECT_EQ(expected_val.browser_type, actual_val.browser_type);
113 EXPECT_EQ(expected_val.usage_stats_enable, actual_val.usage_stats_enable);
114 EXPECT_EQ(expected_val.runtime_only, actual_val.runtime_only);
115
116 EXPECT_EQ(expected_val.apps.size(), actual_val.apps.size());
117
118 for (size_t i = 0; i < actual_val.apps.size(); ++i) {
119 CommandLineAppArgs expected = expected_val.apps[i];
120 CommandLineAppArgs actual = actual_val.apps[i];
121
122 EXPECT_STREQ(GuidToString(expected.app_guid),
123 GuidToString(actual.app_guid));
124 EXPECT_STREQ(expected.app_name, actual.app_name);
125 EXPECT_EQ(expected.needs_admin, actual.needs_admin);
126 EXPECT_STREQ(expected.ap, actual.ap);
127 EXPECT_STREQ(expected.tt_token, actual.tt_token);
128 EXPECT_STREQ(expected.encoded_installer_data,
129 actual.encoded_installer_data);
130 EXPECT_STREQ(expected.install_data_index, actual.install_data_index);
131 EXPECT_STREQ(expected.experiment_labels, actual.experiment_labels);
132 }
133 }
134
135 class CommandLineTest : public testing::Test {
136 protected:
137 CommandLineArgs args_;
138 CommandLineArgs expected_;
139 };
140
141 TEST(CommandLineSimpleTest, GetCmdLineTail1) {
142 EXPECT_STREQ(_T(""), GetCmdLineTail(_T("")));
143 }
144
145 TEST(CommandLineSimpleTest, GetCmdLineTail2) {
146 EXPECT_STREQ(_T(""), GetCmdLineTail(_T("a")));
147 }
148 TEST(CommandLineSimpleTest, GetCmdLineTail3) {
149 EXPECT_STREQ(_T(""), GetCmdLineTail(_T("goopdate.exe")));
150 }
151
152 TEST(CommandLineSimpleTest, GetCmdLineTail4) {
153 // Double quotes.
154 EXPECT_STREQ(_T(""), GetCmdLineTail(_T("\"Google Update.exe\"")));
155 }
156
157 TEST(CommandLineSimpleTest, GetCmdLineTail5) {
158 // Argument.
159 EXPECT_STREQ(_T("foobar"), GetCmdLineTail(_T("goopdate.exe foobar")));
160 }
161
162 TEST(CommandLineSimpleTest, GetCmdLineTail6) {
163 // Double quotes and argument.
164 EXPECT_STREQ(_T("foobar"),
165 GetCmdLineTail(_T("\"Google Update.exe\" foobar")));
166 }
167
168 TEST(CommandLineSimpleTest, GetCmdLineTail7) {
169 // Double quotes and inner double quote and argument.
170 EXPECT_STREQ(_T("foobar"),
171 GetCmdLineTail(_T("\"Google\"\" Update.exe\" foobar")));
172 }
173
174 TEST(CommandLineSimpleTest, GetCmdLineTail8) {
175 // Double quotes and two arguments.
176 EXPECT_STREQ(_T("foo bar"),
177 GetCmdLineTail(_T("\"Google Update.exe\" foo bar")));
178 }
179
180 TEST(CommandLineSimpleTest, GetCmdLineTail9) {
181 // Double quotes and one argument with quotes.
182 EXPECT_STREQ(_T("\"foo bar\""),
183 GetCmdLineTail(_T("\"Google Update.exe\" \"foo bar\"")));
184 }
185
186 TEST(CommandLineSimpleTest, GetCmdLineTail10) {
187 // \t as white space.
188 EXPECT_STREQ(_T("foo bar"),
189 GetCmdLineTail(_T("\"Google Update.exe\"\tfoo bar")));
190 }
191
192 TEST(CommandLineSimpleTest, GetCmdLineTail11) {
193 // Trailing space.
194 EXPECT_STREQ(_T("foo bar "),
195 GetCmdLineTail(_T("\"Google Update.exe\" foo bar ")));
196 }
197
198 //
199 // This block contains the positive test cases for each of the command lines.
200 // If you add a new command line parameter permutation, add a test case here.
201 //
202
203 // TODO(omaha): Add some negative failure cases to the command lines (like
204 // /install without "extraargs").
205
206 // TODO(omaha): This is an Omaha1 back-compat issue. Omaha2 should _never_
207 // call googleupdate.exe with no arguments. So when we stop supporting Omaha1
208 // handoffs we should remove this support.
209 // Parse empty command line.
210 TEST_F(CommandLineTest, ParseCommandLine_Empty) {
211 const TCHAR* kCmdLine = _T("");
212 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
213
214 expected_.mode = COMMANDLINE_MODE_NOARGS;
215 VerifyCommandLineArgs(expected_, args_);
216 }
217
218 // Parse: <path>
219 // Remember that by convention the OS is passing us the program executable
220 // name as the first token in the command line and the parsing code skips that.
221 TEST_F(CommandLineTest, ParseCommandLine_ProgramNameOnly) {
222 const TCHAR* kCmdLine = _T("goopdate.exe");
223 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
224
225 expected_.mode = COMMANDLINE_MODE_NOARGS;
226 VerifyCommandLineArgs(expected_, args_);
227 }
228
229 // Parse: <path> /svc
230 TEST_F(CommandLineTest, ParseCommandLine_Svc) {
231 const TCHAR* kCmdLine = _T("\"C:\\Program Files\\Google\\Common\\Update\\")
232 _T("1.0.18.0\\goopdate.exe\" /svc");
233 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
234
235 expected_.mode = COMMANDLINE_MODE_SERVICE;
236 VerifyCommandLineArgs(expected_, args_);
237 }
238
239 // Parse: <path> /medsvc
240 TEST_F(CommandLineTest, ParseCommandLine_MedSvc) {
241 const TCHAR* kCmdLine = _T("\"C:\\Program Files\\Google\\Common\\Update\\")
242 _T("1.0.18.0\\goopdate.exe\" /medsvc");
243 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
244
245 expected_.mode = COMMANDLINE_MODE_MEDIUM_SERVICE;
246 VerifyCommandLineArgs(expected_, args_);
247 }
248
249 // Parse: <path> -Embedding. The -Embedding text is injected via COM.
250 TEST_F(CommandLineTest, ParseCommandLine_Server) {
251 const TCHAR* kCmdLine = _T("goopdate.exe -Embedding");
252 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
253
254 expected_.mode = COMMANDLINE_MODE_COMSERVER;
255 VerifyCommandLineArgs(expected_, args_);
256 }
257
258 // Parse: <path> /broker. Used for the special COM broker mode.
259 TEST_F(CommandLineTest, ParseCommandLine_Broker) {
260 const TCHAR* kCmdLine = _T("goopdate.exe /broker");
261 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
262
263 expected_.mode = COMMANDLINE_MODE_COMBROKER;
264 VerifyCommandLineArgs(expected_, args_);
265 }
266
267 // Parse: <path> /ondemand.
268 TEST_F(CommandLineTest, ParseCommandLine_OnDemand) {
269 const TCHAR* kCmdLine = _T("goopdate.exe /ondemand");
270 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
271
272 expected_.mode = COMMANDLINE_MODE_ONDEMAND;
273 VerifyCommandLineArgs(expected_, args_);
274 }
275
276 // Parse: <path> /install "extraargs"
277 // Also tests that bundle_name takes the first app's appname when no bundlename
278 // is specified.
279 TEST_F(CommandLineTest, ParseCommandLine_Install) {
280 const TCHAR* kCmdLine =
281 _T("goopdate.exe /install ")
282 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
283 _T("appname=YouTubeUploader&needsadmin=False&")
284 _T("appguid={C7A9A2F5-C4F9-42d3-8A8B-55086A205468}&")
285 _T("appname=TestApp&needsadmin=true&lang=en\"");
286 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
287
288 expected_.mode = COMMANDLINE_MODE_INSTALL;
289
290 expected_.extra_args_str = _T("appguid=")
291 _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
292 _T("appname=YouTubeUploader&needsadmin=False&")
293 _T("appguid=")
294 _T("{C7A9A2F5-C4F9-42d3-8A8B-55086A205468}&")
295 _T("appname=TestApp&needsadmin=true&lang=en");
296 CommandLineAppArgs app_args;
297 const GUID expected_guid = {0xA4F7B07B, 0xB9BD, 0x4A33,
298 {0xB1, 0x36, 0x96, 0xD2, 0xAD, 0xFB, 0x60, 0xCB}};
299 app_args.app_guid = expected_guid;
300 app_args.app_name = _T("YouTubeUploader");
301 app_args.needs_admin = NEEDS_ADMIN_NO;
302 expected_.extra.apps.push_back(app_args);
303
304 CommandLineAppArgs app_args1;
305 app_args1.app_guid =
306 StringToGuid(_T("{C7A9A2F5-C4F9-42d3-8A8B-55086A205468}"));
307 app_args1.app_name = _T("TestApp");
308 app_args1.needs_admin = NEEDS_ADMIN_YES;
309 expected_.extra.apps.push_back(app_args1);
310
311 expected_.extra.bundle_name = _T("YouTubeUploader");
312 expected_.extra.language = _T("en");
313
314 VerifyCommandLineArgs(expected_, args_);
315
316 EXPECT_STREQ(_T("YouTubeUploader"), args_.extra.bundle_name);
317 }
318
319 // Parse: <path> /install "bundlename=My%20Bundle&extraargs"
320 // Tests bundlename override of appname.
321 TEST_F(CommandLineTest, ParseCommandLine_Install_BundleName) {
322 const TCHAR* kCmdLine =
323 _T("goopdate.exe /install ")
324 _T("\"bundlename=My%20Bundle&")
325 _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
326 _T("appname=YouTubeUploader&needsadmin=False&\"");
327 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
328
329 expected_.mode = COMMANDLINE_MODE_INSTALL;
330
331 expected_.extra_args_str = _T("bundlename=My%20Bundle&appguid=")
332 _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
333 _T("appname=YouTubeUploader&needsadmin=False&");
334 CommandLineAppArgs app_args;
335 const GUID expected_guid = {0xA4F7B07B, 0xB9BD, 0x4A33,
336 {0xB1, 0x36, 0x96, 0xD2, 0xAD, 0xFB, 0x60, 0xCB}};
337 app_args.app_guid = expected_guid;
338 app_args.app_name = _T("YouTubeUploader");
339 app_args.needs_admin = NEEDS_ADMIN_NO;
340 expected_.extra.apps.push_back(app_args);
341
342 expected_.extra.bundle_name = _T("My Bundle");
343
344 VerifyCommandLineArgs(expected_, args_);
345
346 EXPECT_STREQ(_T("My Bundle"), args_.extra.bundle_name);
347 }
348
349 // Parse: <path> /install "extraargs" /oem
350 TEST_F(CommandLineTest, ParseCommandLine_InstallWithOem) {
351 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
352 _T(" /oem");
353 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
354
355 expected_.mode = COMMANDLINE_MODE_INSTALL;
356 expected_.is_oem_set = true;
357 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
358 }
359
360 // Parse: <path> /install "extraargs" [/oem
361 // This tests how we handle a switch with a bracket, which represents optional
362 // parameters in a rule, when it appears in an actual command line.
363 TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemIgnored) {
364 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
365 _T(" [/oem");
366 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
367
368 expected_.mode = COMMANDLINE_MODE_INSTALL;
369 expected_.is_oem_set = false;
370 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
371 }
372
373 // Parse: <path> /install "extraargs" /appargs <appargs>
374 TEST_F(CommandLineTest, ParseCommandLine_InstallWithAppArgs) {
375 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
376 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS;
377 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
378
379 expected_.mode = COMMANDLINE_MODE_INSTALL;
380 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
381 }
382
383 // Parse: <path> /install "extraargs" /oem /appargs <appargs>
384 TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemAppArgs) {
385 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
386 _T(" /oem")
387 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS;
388 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
389
390 expected_.mode = COMMANDLINE_MODE_INSTALL;
391 expected_.is_oem_set = true;
392 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
393 }
394
395 // Parse: <path> /install "extraargs" /appargs <appargs> /silent
396 TEST_F(CommandLineTest, ParseCommandLine_InstallWithAppArgsSilent) {
397 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
398 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
399 _T(" /silent");
400 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
401
402 expected_.mode = COMMANDLINE_MODE_INSTALL;
403 expected_.is_silent_set = true;
404 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
405 }
406
407 // Parse: <path> /install "extraargs" /oem /appargs <appargs> /silent
408 TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemAppArgsSilent) {
409 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
410 _T(" /oem")
411 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
412 _T(" /silent");
413 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
414
415 expected_.mode = COMMANDLINE_MODE_INSTALL;
416 expected_.is_oem_set = true;
417 expected_.is_silent_set = true;
418 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
419 }
420
421 // Parse:
422 // <path> /install "extraargs" /oem /appargs <appargs> /silent /eularequired
423 TEST_F(CommandLineTest,
424 ParseCommandLine_InstallWithOemAppArgsSilentEulaRequired) {
425 const TCHAR* kCmdLine =
426 _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
427 _T(" /oem")
428 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
429 _T(" /silent")
430 _T(" /eularequired");
431 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
432
433 expected_.mode = COMMANDLINE_MODE_INSTALL;
434 expected_.is_oem_set = true;
435 expected_.is_silent_set = true;
436 expected_.is_eula_required_set = true;
437 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
438 }
439
440 // Parse: <path> /install "extraargs" /eularequired
441 TEST_F(CommandLineTest, ParseCommandLine_InstallEulaRequired) {
442 const TCHAR* kCmdLine =
443 _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
444 _T(" /eularequired");
445 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
446
447 expected_.mode = COMMANDLINE_MODE_INSTALL;
448 expected_.is_eula_required_set = true;
449 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
450 }
451
452 // Parse: <path> /install "extraargs" /oem /installsource oneclick
453 TEST_F(CommandLineTest, ParseCommandLine_InstallWithOemAndSource) {
454 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
455 _T(" /oem")
456 _T(" /installsource oneclick");
457 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
458
459 expected_.mode = COMMANDLINE_MODE_INSTALL;
460 expected_.is_oem_set = true;
461 expected_.install_source = _T("oneclick");
462 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
463 }
464
465 // Parse: <path> /install "extraargs" /installsource oneclick
466 TEST_F(CommandLineTest, ParseCommandLine_InstallWithSource) {
467 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
468 _T(" /installsource oneclick");
469 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
470
471 expected_.mode = COMMANDLINE_MODE_INSTALL;
472 expected_.install_source = _T("oneclick");
473 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
474 }
475
476 // Parse: <path> /install "extraargs" /silent
477 TEST_F(CommandLineTest, ParseCommandLine_InstallSilent) {
478 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
479 _T(" /silent");
480 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
481
482 expected_.mode = COMMANDLINE_MODE_INSTALL;
483 expected_.is_silent_set = true;
484 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
485 }
486
487 // Parse: <path> /install "extraargs" /silent /oem
488 TEST_F(CommandLineTest, ParseCommandLine_InstallSilentWithOem) {
489 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
490 _T(" /silent")
491 _T(" /oem");
492 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
493
494 expected_.mode = COMMANDLINE_MODE_INSTALL;
495 expected_.is_silent_set = true;
496 expected_.is_oem_set = true;
497 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
498 }
499
500 // Parse: <path> /install "extraargs" /installsource oneclick /silent
501 TEST_F(CommandLineTest, ParseCommandLine_InstallSilentWithSource) {
502 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
503 _T(" /installsource oneclick")
504 _T(" /silent");
505 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
506
507 expected_.mode = COMMANDLINE_MODE_INSTALL;
508 expected_.install_source = _T("oneclick");
509 expected_.is_silent_set = true;
510 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
511 }
512
513 // Parse: <path> /install "extraargs" /installelevated
514 TEST_F(CommandLineTest, ParseCommandLine_InstallElevated) {
515 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
516 _T(" /installelevated");
517 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
518
519 expected_.mode = COMMANDLINE_MODE_INSTALL;
520 expected_.is_install_elevated = true;
521 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
522 }
523
524 // Parse: <path> /install "extraargs" /installelevated /installsource oneclick
525 TEST_F(CommandLineTest, ParseCommandLine_InstallElevatedWithSource) {
526 const TCHAR* kCmdLine = _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
527 _T(" /installelevated /installsource oneclick");
528 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
529
530 expected_.mode = COMMANDLINE_MODE_INSTALL;
531 expected_.is_install_elevated = true;
532 expected_.install_source = _T("oneclick");
533 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
534 }
535
536 // Parse: <path> /install "extraargs" /sessionid "guid"
537 TEST_F(CommandLineTest, ParseCommandLine_InstallSessionId) {
538 const TCHAR* kCmdLine =
539 _T("goopdate.exe /install ") YOUTUBEUPLOADEREN_TAG
540 _T(" /sessionid \"{756dfdc2-0ef0-44b7-bfb1-21a4be6a1213}\"");
541 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
542
543 expected_.mode = COMMANDLINE_MODE_INSTALL;
544 expected_.session_id = _T("{756dfdc2-0ef0-44b7-bfb1-21a4be6a1213}");
545 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
546 }
547
548 // Parse: <path> /ig "extraargs"
549 TEST_F(CommandLineTest, ParseCommandLine_LegacyOmaha2Ig) {
550 const TCHAR* kCmdLine = _T("goopdate.exe /ig ") YOUTUBEUPLOADEREN_TAG;
551 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
552 }
553
554 // Parse: <path> /handoff "extraargs"
555 TEST_F(CommandLineTest, ParseCommandLine_Handoff) {
556 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG;
557 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
558
559 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
560 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
561 }
562
563 // Parse: <path> /handoff "extraargs" /offlinedir "c:\dir\ "
564 TEST_F(CommandLineTest, ParseCommandLine_OfflineDirTrailingBackslashSpace) {
565 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
566 _T(" /offlinedir \"c:\\offline dir\\ \"");
567 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
568
569 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
570 expected_.is_offline_set = true;
571 expected_.offline_dir = _T("c:\\offline dir");
572 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
573 }
574
575 // Parse: <path> /handoff "extraargs" /offlinedir "c:\dir\\"
576 TEST_F(CommandLineTest,
577 ParseCommandLine_OfflineDirTrailingDoubleBackslashNoSpace) {
578 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
579 _T(" /offlinedir \"c:\\offline dir\\\\\"");
580 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
581
582 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
583 expected_.is_offline_set = true;
584 expected_.offline_dir = _T("c:\\offline dir");
585 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
586 }
587
588 // Parse: <path> /handoff "extraargs" /offlinedir "c:\dir\"
589 TEST_F(CommandLineTest, ParseCommandLine_OfflineDirTrailingBackslashNoSpace) {
590 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
591 _T(" /offlinedir \"c:\\offline dir\\\"");
592 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
593
594 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
595 expected_.is_offline_set = true;
596 expected_.offline_dir = _T("c:\\offline dir");
597 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
598 }
599
600 // Parse: <path> /handoff "extraargs" /installsource "asd"
601 TEST_F(CommandLineTest, ParseCommandLine_HandoffWithSource) {
602 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
603 _T(" /installsource oneclick");
604 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
605
606 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
607 expected_.install_source = _T("oneclick");
608 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
609 }
610
611 // Parse: <path> /handoff "extraargs" /installsource offline /offlineinstall
612 TEST_F(CommandLineTest, ParseCommandLine_HandoffWithSourceOffline) {
613 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
614 _T(" /installsource offline")
615 _T(" /offlineinstall");
616 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
617
618 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
619 expected_.install_source = _T("offline");
620 expected_.is_offline_set = true;
621 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
622 }
623
624 // Parse: <path> /handoff "extraargs" /appargs <appargs>
625 // /installsource offline /offlinedir "dir"
626 TEST_F(CommandLineTest, ParseCommandLine_HandoffWithAppArgsSourceOffline) {
627 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
628 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
629 _T(" /installsource offline")
630 _T(" /offlinedir \"c:\\offline_dir\"");
631 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
632
633 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
634 expected_.install_source = _T("offline");
635 expected_.is_offline_set = true;
636 expected_.offline_dir = _T("c:\\offline_dir");
637 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
638 }
639
640 // Parse: <path> /handoff "extraargs" /silent
641 TEST_F(CommandLineTest, ParseCommandLine_HandoffSilent) {
642 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
643 _T(" /silent");
644 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
645
646 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
647 expected_.is_silent_set = true;
648 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
649 }
650
651 // Parse: <path> /handoff "extraargs" /silent /offlineinstall
652 TEST_F(CommandLineTest,
653 ParseCommandLine_HandoffSilentOfflineWithoutInstallSource) {
654 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
655 _T(" /silent")
656 _T(" /offlineinstall");
657 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
658
659 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
660 expected_.is_silent_set = true;
661 expected_.is_offline_set = true;
662 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
663 }
664
665 // Parse: <path> /handoff "extraargs" /installsource "asd" /silent
666 TEST_F(CommandLineTest, ParseCommandLine_HandoffSilentWithSource) {
667 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
668 _T(" /installsource oneclick")
669 _T(" /silent");
670 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
671
672 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
673 expected_.install_source = _T("oneclick");
674 expected_.is_silent_set = true;
675 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
676 }
677
678 // Parse:
679 // <path> /handoff "extraargs" /installsource offline /silent /offlineinstall
680 TEST_F(CommandLineTest, ParseCommandLine_HandoffSilentWithSourceOffline) {
681 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
682 _T(" /installsource offline")
683 _T(" /silent")
684 _T(" /offlineinstall");
685 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
686
687 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
688 expected_.install_source = _T("offline");
689 expected_.is_silent_set = true;
690 expected_.is_offline_set = true;
691 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
692 }
693
694 // Parse: <path> /handoff "extraargs" /appargs <appargs>
695 TEST_F(CommandLineTest, ParseCommandLine_HandoffWithAppArgs) {
696 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
697 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS;
698 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
699
700 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
701 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
702 }
703
704 // Parse: <path> /handoff "extraargs" /appargs <appargs> /silent
705 TEST_F(CommandLineTest, ParseCommandLine_HandoffSilentWithAppArgs) {
706 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
707 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
708 _T(" /silent");
709 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
710
711 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
712 expected_.is_silent_set = true;
713 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
714 }
715
716 // Parse: <path> /handoff "extraargs" /appargs <appargs>
717 // /installsource offline /silent /offlineinstall
718 TEST_F(CommandLineTest,
719 ParseCommandLine_HandoffSilentWithAppArgsSourceOffline) {
720 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
721 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
722 _T(" /installsource offline")
723 _T(" /silent")
724 _T(" /offlineinstall");
725 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
726
727 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
728 expected_.install_source = _T("offline");
729 expected_.is_silent_set = true;
730 expected_.is_offline_set = true;
731 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
732 }
733
734 // Parse: <path> /handoff "extraargs" /appargs <appargs>
735 // /installsource offline /silent /offlineinstall /eularequired
736 TEST_F(CommandLineTest,
737 ParseCommandLine_HandoffSilentWithAppArgsSourceOfflineEulaRequired) {
738 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
739 _T(" /appargs ") YOUTUBEUPLOADEREN_APP_ARGS
740 _T(" /installsource offline")
741 _T(" /silent")
742 _T(" /offlineinstall")
743 _T(" /eularequired");
744 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
745
746 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
747 expected_.install_source = _T("offline");
748 expected_.is_silent_set = true;
749 expected_.is_offline_set = true;
750 expected_.is_eula_required_set = true;
751 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, true, true);
752 }
753
754 // Parse: <path> /handoff "extraargs" /eularequired
755 TEST_F(CommandLineTest, ParseCommandLine_HandoffEulaRequired) {
756 const TCHAR* kCmdLine = _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
757 _T(" /eularequired");
758
759 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
760
761 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
762 expected_.is_eula_required_set = true;
763 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
764 }
765
766 // Parse: <path> /handoff "extraargs" /sessionid "guid"
767 TEST_F(CommandLineTest, ParseCommandLine_HandoffSessionId) {
768 const TCHAR* kCmdLine =
769 _T("goopdate.exe /handoff ") YOUTUBEUPLOADEREN_TAG
770 _T(" /sessionid \"{756dfdc2-0ef0-44b7-bfb1-21a4be6a1213}\"");
771
772 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
773
774 expected_.mode = COMMANDLINE_MODE_HANDOFF_INSTALL;
775 expected_.session_id = _T("{756dfdc2-0ef0-44b7-bfb1-21a4be6a1213}");
776 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, true);
777 }
778
779 // Parse: <path> /ug
780 TEST_F(CommandLineTest, ParseCommandLine_LegacyOmaha2Ug) {
781 const TCHAR* kCmdLine = _T("goopdate.exe /ug");
782 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
783 }
784
785 // Parse: <path> /ua
786 TEST_F(CommandLineTest, ParseCommandLine_UaNoInstallSource) {
787 const TCHAR* kCmdLine = _T("goopdate.exe /ua");
788 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
789
790 expected_.mode = COMMANDLINE_MODE_UA;
791 VerifyCommandLineArgs(expected_, args_);
792 }
793
794 // Parse: <path> /ua /installsource core
795 TEST_F(CommandLineTest, ParseCommandLine_Ua) {
796 const TCHAR* kCmdLine = _T("goopdate.exe /ua /installsource core");
797 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
798
799 expected_.mode = COMMANDLINE_MODE_UA;
800 expected_.install_source = _T("core");
801 VerifyCommandLineArgs(expected_, args_);
802 }
803
804 // Parse: <path> /update
805 TEST_F(CommandLineTest, ParseCommandLine_Update) {
806 const TCHAR* kCmdLine = _T("goopdate.exe /update");
807 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
808
809 expected_.mode = COMMANDLINE_MODE_UPDATE;
810 VerifyCommandLineArgs(expected_, args_);
811 }
812
813 // Parse: <path> /update /sessionid "guid"
814 TEST_F(CommandLineTest, ParseCommandLine_UpdateSessionId) {
815 const TCHAR* kCmdLine =
816 _T("goopdate.exe /update");
817 _T(" /sessionid \"{756dfdc2-0ef0-44b7-bfb1-21a4be6a1213}\"");
818 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
819
820 expected_.mode = COMMANDLINE_MODE_UPDATE;
821 expected_.session_id = _T("{756dfdc2-0ef0-44b7-bfb1-21a4be6a1213}");
822 VerifyCommandLineArgs(expected_, args_);
823 }
824
825 // Parse: <path> /netdiags
826 TEST_F(CommandLineTest, ParseCommandLine_NetDiags) {
827 const TCHAR* kCmdLine = _T("goopdate.exe /netdiags");
828 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
829
830 expected_.mode = COMMANDLINE_MODE_NETDIAGS;
831 VerifyCommandLineArgs(expected_, args_);
832 }
833
834 // Parse: <path> /regserver
835 TEST_F(CommandLineTest, ParseCommandLine_Regserver) {
836 const TCHAR* kCmdLine = _T("goopdate.exe /regserver");
837 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
838
839 expected_.mode = COMMANDLINE_MODE_REGSERVER;
840 VerifyCommandLineArgs(expected_, args_);
841 }
842
843 // Parse: <path> /unregserver
844 TEST_F(CommandLineTest, ParseCommandLine_Unregserver) {
845 const TCHAR* kCmdLine = _T("goopdate.exe /unregserver");
846 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
847
848 expected_.mode = COMMANDLINE_MODE_UNREGSERVER;
849 VerifyCommandLineArgs(expected_, args_);
850 }
851
852 // Parse: <path> /registerproduct
853 TEST_F(CommandLineTest, ParseCommandLine_RegisterProduct) {
854 const TCHAR* kCmdLine =
855 _T("goopdate.exe /registerproduct ")
856 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
857 _T("appname=YouTubeUploader&needsadmin=False\"");
858 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
859
860 expected_.mode = COMMANDLINE_MODE_REGISTER_PRODUCT;
861 expected_.extra_args_str = _T("appguid=")
862 _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
863 _T("appname=YouTubeUploader&needsadmin=False");
864 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, false);
865 }
866
867 // Parse: <path> /registerproduct /installsource enterprisemsi
868 TEST_F(CommandLineTest, ParseCommandLine_RegisterProductWithInstallSource) {
869 const TCHAR* kCmdLine =
870 _T("goopdate.exe /registerproduct ")
871 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
872 _T("appname=YouTubeUploader&needsadmin=False\"")
873 _T(" /installsource enterprisemsi");
874 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
875 expected_.mode = COMMANDLINE_MODE_REGISTER_PRODUCT;
876 expected_.install_source = _T("enterprisemsi");
877 expected_.extra_args_str = _T("appguid=")
878 _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
879 _T("appname=YouTubeUploader&needsadmin=False");
880 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, false);
881 }
882
883 // Parse: <path> /unregisterproduct
884 TEST_F(CommandLineTest, ParseCommandLine_UnregisterProduct) {
885 const TCHAR* kCmdLine =
886 _T("goopdate.exe /unregisterproduct ")
887 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
888 _T("appname=YouTubeUploader&needsadmin=False\"");
889 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
890
891 expected_.mode = COMMANDLINE_MODE_UNREGISTER_PRODUCT;
892 expected_.extra_args_str = _T("appguid=")
893 _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
894 _T("appname=YouTubeUploader&needsadmin=False");
895 VerifyArgsWithSingleYouTubeUploaderEnApp(expected_, args_, false, false);
896 }
897
898 // Parse: <path> /c
899 TEST_F(CommandLineTest, ParseCommandLine_Core) {
900 const TCHAR* kCmdLine = _T("goopdate.exe /c");
901 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
902
903 expected_.mode = COMMANDLINE_MODE_CORE;
904 expected_.is_crash_handler_disabled = false;
905 VerifyCommandLineArgs(expected_, args_);
906 }
907
908 // Parse: <path> /c /nocrashserver
909 TEST_F(CommandLineTest, ParseCommandLine_CoreNoCrashHandler) {
910 const TCHAR* kCmdLine = _T("goopdate.exe /c /nocrashserver");
911 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
912
913 expected_.mode = COMMANDLINE_MODE_CORE;
914 expected_.is_crash_handler_disabled = true;
915 VerifyCommandLineArgs(expected_, args_);
916 }
917
918 // Parse: <path> /crash
919 TEST_F(CommandLineTest, ParseCommandLine_Crash) {
920 const TCHAR* kCmdLine = _T("goopdate.exe /crash");
921 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
922
923 expected_.mode = COMMANDLINE_MODE_CRASH;
924 VerifyCommandLineArgs(expected_, args_);
925 }
926
927 // Parse: <path> /report crash_file
928 TEST_F(CommandLineTest, ParseCommandLine_Report) {
929 const TCHAR* kCmdLine = _T("goopdate.exe /report C:\\foo\\crash.dmp");
930 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
931
932 expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
933 expected_.crash_filename = _T("C:\\foo\\crash.dmp");
934 VerifyCommandLineArgs(expected_, args_);
935 }
936
937 // Parse: <path> /report crash_file /machine
938 TEST_F(CommandLineTest, ParseCommandLine_ReportMachine) {
939 const TCHAR* kCmdLine =
940 _T("goopdate.exe /report C:\\foo\\crash.dmp /machine");
941 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
942
943 expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
944 expected_.crash_filename = _T("C:\\foo\\crash.dmp");
945 expected_.is_machine_set = true;
946 VerifyCommandLineArgs(expected_, args_);
947 }
948
949 // Parse: <path> /report crash_file
950 TEST_F(CommandLineTest, ParseCommandLine_ReportWithCustomInfo) {
951 const TCHAR* kCmdLine =
952 _T("goopdate.exe /report C:\\foo.dmp /custom_info_filename C:\\foo.txt");
953 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
954
955 expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
956 expected_.crash_filename = _T("C:\\foo.dmp");
957 expected_.custom_info_filename = _T("C:\\foo.txt");
958 VerifyCommandLineArgs(expected_, args_);
959 }
960
961 // Parse: <path> /report /i crash_file
962 TEST_F(CommandLineTest, ParseCommandLine_ReportInteractive) {
963 const TCHAR* kCmdLine = _T("goopdate.exe /report /i C:\\foo\\crash.dmp");
964 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
965
966 expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
967 expected_.is_interactive_set = true;
968 expected_.crash_filename = _T("C:\\foo\\crash.dmp");
969 VerifyCommandLineArgs(expected_, args_);
970 }
971
972 // Parse: <path> /report /i crash_file /machine
973 TEST_F(CommandLineTest, ParseCommandLine_ReportMachineInteractive) {
974 const TCHAR*
975 kCmdLine = _T("goopdate.exe /report /i C:\\foo\\crash.dmp /machine");
976 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
977
978 expected_.mode = COMMANDLINE_MODE_REPORTCRASH;
979 expected_.is_machine_set = true;
980 expected_.is_interactive_set = true;
981 expected_.crash_filename = _T("C:\\foo\\crash.dmp");
982 VerifyCommandLineArgs(expected_, args_);
983 }
984
985 TEST_F(CommandLineTest, ParseCommandLine_CodeRedCheck) {
986 const TCHAR* kCmdLine = _T("goopdate.exe /cr");
987 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
988
989 expected_.mode = COMMANDLINE_MODE_CODE_RED_CHECK;
990 VerifyCommandLineArgs(expected_, args_);
991 }
992
993 TEST_F(CommandLineTest, ParseCommandLine_WebPlugin) {
994 const TCHAR* kCmdLine = _T("goopdate.exe /pi \"http://gears.google.com/\" ")
995 _T("\"/install foo\" /installsource oneclick ");
996 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
997
998 expected_.mode = COMMANDLINE_MODE_WEBPLUGIN;
999 expected_.webplugin_urldomain = _T("http://gears.google.com/");
1000 expected_.webplugin_args = _T("/install foo");
1001 expected_.install_source = _T("oneclick");
1002 VerifyCommandLineArgs(expected_, args_);
1003 }
1004
1005 TEST_F(CommandLineTest, ParseCommandLine_WebPluginUrlEscaped) {
1006 const TCHAR* kCmdLine = _T("goopdate.exe /pi \"http://gears.google.com/\" ")
1007 _T("\"/install%20foo\" /installsource oneclick ");
1008 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
1009
1010 expected_.mode = COMMANDLINE_MODE_WEBPLUGIN;
1011 expected_.webplugin_urldomain = _T("http://gears.google.com/");
1012 expected_.webplugin_args = _T("/install foo");
1013 expected_.install_source = _T("oneclick");
1014 VerifyCommandLineArgs(expected_, args_);
1015 }
1016
1017 TEST_F(CommandLineTest, ParseCommandLine_WebPluginTestStringTrim) {
1018 const TCHAR* kCmdLine = _T("goopdate.exe /pi ")
1019 _T("\" http://gears.google.com/ \" ")
1020 _T("\"/install foo\" /installsource oneclick ");
1021 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
1022
1023 expected_.mode = COMMANDLINE_MODE_WEBPLUGIN;
1024 expected_.webplugin_urldomain = _T("http://gears.google.com/");
1025 expected_.webplugin_args = _T("/install foo");
1026 expected_.install_source = _T("oneclick");
1027 VerifyCommandLineArgs(expected_, args_);
1028 }
1029
1030 TEST_F(CommandLineTest, ParseCommandLine_LegacyOmaha1UiNoLanguage) {
1031 const TCHAR* kCmdLine = _T("goopdate.exe /ui \"manifestfilename.xml\"");
1032 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1033 }
1034
1035 TEST_F(CommandLineTest, ParseCommandLine_LegacyOmaha1UiWithLanguage) {
1036 const TCHAR* kCmdLine =
1037 _T("goopdate.exe /ui /lang fr \"manifestfilename.xml\"");
1038 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1039 }
1040
1041 TEST_F(CommandLineTest, ParseCommandLine_LegacyOmaha1UiUser) {
1042 const TCHAR* kCmdLine = _T("goopdate.exe /uiuser file.gup");
1043 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1044 }
1045
1046 TEST_F(CommandLineTest, ParseCommandLine_Recover) {
1047 const TCHAR* kCmdLine = _T("goopdate.exe /recover repairfile.exe");
1048 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
1049
1050 expected_.mode = COMMANDLINE_MODE_RECOVER;
1051 expected_.code_red_metainstaller_path = _T("repairfile.exe");
1052 VerifyCommandLineArgs(expected_, args_);
1053 }
1054
1055 TEST_F(CommandLineTest, ParseCommandLine_RecoverMachine) {
1056 const TCHAR* kCmdLine = _T("goopdate.exe /recover /machine repfile.exe");
1057 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
1058
1059 expected_.mode = COMMANDLINE_MODE_RECOVER;
1060 expected_.is_machine_set = true;
1061 expected_.code_red_metainstaller_path = _T("repfile.exe");
1062 VerifyCommandLineArgs(expected_, args_);
1063 }
1064
1065 // Parse: <path> /uninstall
1066 TEST_F(CommandLineTest, ParseCommandLine_Uninstall) {
1067 const TCHAR* kCmdLine = _T("goopdate.exe /uninstall");
1068 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
1069
1070 expected_.mode = COMMANDLINE_MODE_UNINSTALL;
1071 VerifyCommandLineArgs(expected_, args_);
1072 }
1073
1074 // Parse: <path> /ping foo
1075 TEST_F(CommandLineTest, ParseCommandLine_Ping) {
1076 const TCHAR* kCmdLine = _T("goopdate.exe /ping foo");
1077 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
1078
1079 expected_.mode = COMMANDLINE_MODE_PING;
1080 expected_.ping_string = _T("foo");
1081 VerifyCommandLineArgs(expected_, args_);
1082 }
1083
1084 //
1085 // These are additional failure cases against the command line parsing.
1086 // Everything from here on down should fail ParseCommandLine().
1087 //
1088
1089
1090 // Parse: <path> manifest_file
1091 TEST_F(CommandLineTest, ParseCommandLine_GoopdateJustArg) {
1092 const TCHAR* kCmdLine = _T("goopdate.exe \"foo bar\"");
1093 ExpectAsserts expect_asserts;
1094 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1095 }
1096
1097 // Parse: <path> /install manifest_file manifest_file
1098 // Fails since this is an invalid command line set.
1099 TEST_F(CommandLineTest, ParseCommandLine_Invalid) {
1100 const TCHAR* kCmdLine = _T("goopdate.exe /install \"foo bar\" foobar");
1101 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1102 }
1103
1104 // Parse: <path> /recover
1105 TEST_F(CommandLineTest, Recover_WithoutFile) {
1106 const TCHAR* kCmdLine = _T("goopdate.exe /recover");
1107 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1108 }
1109
1110 // Parse: <path> /machine
1111 TEST_F(CommandLineTest, MachineWithoutRecover) {
1112 const TCHAR* kCmdLine = _T("goopdate.exe /machine");
1113 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1114 }
1115
1116 TEST_F(CommandLineTest, ExtraArgsHasDoubleQuoteInTheMiddle) {
1117 const TCHAR* kCmdLine = _T("goopdate.exe /install \"some_\"file\"");
1118 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1119 }
1120
1121 TEST_F(CommandLineTest, CommandsNotSeparatedBySpaces) {
1122 const TCHAR* kCmdLine = _T("goopdate.exe /recover/machine");
1123 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1124 }
1125
1126 TEST_F(CommandLineTest, CommandsDoNotHaveForwardSlashes) {
1127 const TCHAR* kCmdLine = _T("goopdate.exe recover machine");
1128 ExpectAsserts expect_asserts;
1129 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1130 }
1131
1132 TEST_F(CommandLineTest, UnknownParameter) {
1133 const TCHAR* kCmdLine = _T("goopdate.exe /someunknowncommand");
1134 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1135 }
1136
1137 TEST_F(CommandLineTest, UiWithLangNoLanguage) {
1138 const TCHAR* kCmdLine = _T("goopdate.exe /ui /lang \"manifestfilename.xml\"");
1139 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1140 }
1141
1142 TEST_F(CommandLineTest, WebPluginInstallSourceInvalid_IncorrectValue) {
1143 const TCHAR* kCmdLine = _T("goopdate.exe /installsource invalid /pi ")
1144 _T("\" http://gears.google.com/ \" ");
1145 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1146 }
1147
1148 TEST_F(CommandLineTest, WebPluginInstallSourceInvalid_Empty) {
1149 const TCHAR* kCmdLine = _T("goopdate.exe /installsource /pi ")
1150 _T("\" http://gears.google.com/ \" ");
1151 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1152 }
1153
1154 // Parse: <path> /handoff "extraargs" /lang "en"
1155 TEST_F(CommandLineTest, ParseCommandLine_HandoffLegacyOmaha1ToOmaha2) {
1156 const TCHAR* kCmdLine =
1157 _T("goopdate.exe /handoff ")
1158 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
1159 _T("appname=YouTubeUploader&needsadmin=False\"")
1160 _T(" /lang en");
1161 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1162 }
1163
1164 // Parse: <path> /handoff "extraargs" /installsource "asd" /lang "en"
1165 TEST_F(CommandLineTest,
1166 ParseCommandLine_HandoffWithSourceLegacyOmaha1ToOmaha2) {
1167 const TCHAR* kCmdLine =
1168 _T("goopdate.exe /handoff ")
1169 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
1170 _T("appname=YouTubeUploader&needsadmin=False\"")
1171 _T(" /installsource oneclick /lang en");
1172 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1173 }
1174
1175 // Parse: <path> /handoff "extraargs" /installsource "oneclick" /lang "en"
1176 TEST_F(CommandLineTest,
1177 ParseCommandLine_HandoffWithSourceLegacyOmaha1ToOmaha2Both) {
1178 const TCHAR* kCmdLine =
1179 _T("goopdate.exe /handoff ")
1180 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
1181 _T("appname=YouTubeUploader&needsadmin=False&lang=en\"")
1182 _T(" /installsource oneclick /lang en");
1183 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1184 }
1185
1186 // Parse: <path> /install "extraargs" /lang en
1187 TEST_F(CommandLineTest, ParseCommandLine_InstallLegacyOmaha1) {
1188 const TCHAR* kCmdLine =
1189 _T("goopdate.exe /install ")
1190 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
1191 _T("appname=YouTubeUploader&needsadmin=False&")
1192 _T("appguid={C7A9A2F5-C4F9-42d3-8A8B-55086A205468}&")
1193 _T("appname=TestApp&needsadmin=true\" /lang en");
1194 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1195 }
1196
1197 // Parse: <path> /install "extraargs" /installsource oneclick /lang en
1198 TEST_F(CommandLineTest, ParseCommandLine_InstallWithSourceLegacyOmaha1) {
1199 const TCHAR* kCmdLine =
1200 _T("goopdate.exe /install ")
1201 _T("\"appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
1202 _T("appname=YouTubeUploader&needsadmin=False\"")
1203 _T(" /installsource oneclick /lang en");
1204 EXPECT_FAILED(ParseCommandLine(kCmdLine, &args_));
1205 }
1206
1207 TEST_F(CommandLineTest, ParseCommandLine_NeedsAdmin_Prefers) {
1208 const TCHAR* kCmdLine =
1209 _T("goopdate.exe /install ")
1210 _T("\"bundlename=My%20Bundle&")
1211 _T("appguid={A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
1212 _T("appname=YouTubeUploader&needsadmin=Prefers&\"");
1213 EXPECT_SUCCEEDED(ParseCommandLine(kCmdLine, &args_));
1214
1215 expected_.mode = COMMANDLINE_MODE_INSTALL;
1216
1217 expected_.extra_args_str = _T("bundlename=My%20Bundle&appguid=")
1218 _T("{A4F7B07B-B9BD-4a33-B136-96D2ADFB60CB}&")
1219 _T("appname=YouTubeUploader&needsadmin=Prefers&");
1220 CommandLineAppArgs app_args;
1221 const GUID expected_guid = {0xA4F7B07B, 0xB9BD, 0x4A33,
1222 {0xB1, 0x36, 0x96, 0xD2, 0xAD, 0xFB, 0x60, 0xCB}};
1223 app_args.app_guid = expected_guid;
1224 app_args.app_name = _T("YouTubeUploader");
1225 app_args.needs_admin = NEEDS_ADMIN_PREFERS;
1226 expected_.extra.apps.push_back(app_args);
1227
1228 expected_.extra.bundle_name = _T("My Bundle");
1229
1230 VerifyCommandLineArgs(expected_, args_);
1231 }
1232
1233 } // namespace omaha
OLDNEW
« no previous file with comments | « common/command_line_builder_unittest.cc ('k') | common/config_manager.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698