base/commands_unittest.cc - Issue 624713003: Keep only base/extractor.[cc|h].

Side by Side Diff: base/commands_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

OLD	NEW
	(Empty)
1 // Copyright 2006-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 // Unit tests of command line options parsing

17

18 #include <cstdio>

19 #include "omaha/base/commands.h"

20 #include "omaha/base/file.h"

21 #include "omaha/testing/unit_test.h"

22

23 namespace omaha {

24

25 #define kDash _T("-")

26 #define kBoolOption _T("bool")

27 #define kThreeOption _T("three")

28 #define kIntOption _T("int")

29 #define kUintOption _T("uint")

30 #define kStrOption _T("str")

31

32 #define kIEBrowserExe \

33 _T("C:\\PROGRAM FILES\\Internet Explorer\\iexplore.exe")

34

35 #define kIEBrowserQuotedExe \

36 _T("\"") kIEBrowserExe _T("\"")

37

38 #define kIEBrowserQuotedArgs _T("-h \"%1\"")

39 #define kIEBrowserQuotedCommandLine \

40 kIEBrowserQuotedExe _T(" ") kIEBrowserQuotedArgs

41

42 #define kIEBrowserQuotedExeResult \

43 _T("C:\\PROGRAM FILES\\Internet Explorer\\iexplore.exe")

44 #define kIEBrowserQuotedArgsResult _T("-h %1")

45

46 #define kIEBrowserUnquotedCommandLine \

47 _T("C:\\Program Files\\Internet Explorer\\iexplore.exe -nohome")

48 #define kIEBrowserUnquotedExe \

49 _T("C:\\Program Files\\Internet Explorer\\iexplore.exe")

50 #define kIEBrowserUnquotedArgs _T("-nohome")

51

52 #define kGEUninstallCommandLine _T("RunDll32 C:\\PROGRA~1\\COMMON~1\\INSTA L~1\\PROFES~1\\RunTime\\10\\01\\Intel32\\Ctor.dll,LaunchSetup \"C:\\Program File s\\InstallShield Installation Information\\{3DE5E7D4-7B88-403C-A3FD-2017A8240C5B }\\setup.exe\" -l0x9 -removeonly") // NOLINT

53 #define kGEUninstallExe _T("RunDll32")

54 #define kGEUninstallArgs _T("C:\\PROGRA~1\\COMMON~1\\INSTAL~1\\PROF ES~1\\RunTime\\10\\01\\Intel32\\Ctor.dll,LaunchSetup \"C:\\Program Files\\Instal lShield Installation Information\\{3DE5E7D4-7B88-403C-A3FD-2017A8240C5B}\\setup. exe\" -l0x9 -removeonly") // NOLINT

55

56

57 struct TestData {

58 TestData() {

59 Clear();

60 }

61

62 void Clear() {

63 bool_value = false;

64 three_value = VALUE_NOT_SET;

65 int_value = 0;

66 uint_value = 0;

67 str_value.Empty();

68 }

69

70 bool bool_value;

71 ThreeValue three_value;

72 int int_value;

73 uint32 uint_value;

74 CString str_value;

75 };

76

77 void FillTestData(TestData* data) {

78 data->bool_value = true;

79 data->three_value = FALSE_VALUE;

80 data->int_value = -128;

81 data->uint_value = 256;

82 data->str_value = _T("Foo");

83 }

84

85 void CheckTestData(const TestData& d1, const TestData& d2) {

86 EXPECT_EQ(d1.bool_value, d2.bool_value);

87 EXPECT_EQ(d1.three_value, d2.three_value);

88 EXPECT_EQ(d1.int_value, d2.int_value);

89 EXPECT_EQ(d1.uint_value, d2.uint_value);

90 EXPECT_STREQ(d1.str_value, d2.str_value);

91 }

92

93 TEST(CommandsTest, TraditionalCommandLineOptionsParsingTest) {

94 TestData data;

95 FillTestData(&data);

96 CString cmd_line;

97 cmd_line.Format(_T("%s%s %s ")

98 _T("%s%s %d ")

99 _T("%s%s %u ")

100 _T("%s%s %s "),

101 kDash, kThreeOption, (data.three_value == TRUE_VALUE) ? _T("on ") : _T("off"), // NOLINT

102 kDash, kIntOption, data.int_value,

103 kDash, kUintOption, data.uint_value,

104 kDash, kStrOption, data.str_value);

105 if (data.bool_value) {

106 cmd_line.AppendFormat(_T("%s%s"), kDash, kBoolOption);

107 }

108

109 TestData option_data;

110 CommandOption cmd_options[] = {

111 { kDash kBoolOption, COMMAND_OPTION_BOOL, &option_data.bool_value, -1 },

112 { kDash kThreeOption, COMMAND_OPTION_THREE, &option_data.three_value, -1 },

113 { kDash kIntOption, COMMAND_OPTION_INT, &option_data.int_value, -1 },

114 { kDash kUintOption, COMMAND_OPTION_UINT, &option_data.uint_value, -1 },

115 { kDash kStrOption, COMMAND_OPTION_STRING, &option_data.str_value, -1 }

116 };

117

118 option_data.Clear();

119 CommandParsing cmd_parsing(cmd_options, arraysize(cmd_options));

120 ASSERT_SUCCEEDED(cmd_parsing.Parse(cmd_line, false));

121

122 CheckTestData(option_data, data);

123 }

124

125 TEST(CommandsTest, TraditionalIgnoreUnknownArgsParsingTest) {

126 TestData data;

127 FillTestData(&data);

128 CString cmd_line;

129 cmd_line.Format(_T("%s%s %s ")

130 _T("%s%s %d ")

131 _T("%s%s %u ")

132 _T("%s%s %s "),

133 kDash, kThreeOption, (data.three_value == TRUE_VALUE) ? _T("on ") : _T("off"), // NOLINT

134 kDash, kIntOption, data.int_value,

135 kDash, kUintOption, data.uint_value,

136 kDash, kStrOption, data.str_value);

137 if (data.bool_value) {

138 cmd_line.AppendFormat(_T("%s%s"), kDash, kBoolOption);

139 }

140

141 TestData option_data;

142 CommandOption cmd_options[] = {

143 { kDash kThreeOption, COMMAND_OPTION_THREE, &option_data.three_value, -1 },

144 { kDash kIntOption, COMMAND_OPTION_INT, &option_data.int_value, -1 },

145 { kDash kUintOption, COMMAND_OPTION_UINT, &option_data.uint_value, -1 },

146 { kDash kStrOption, COMMAND_OPTION_STRING, &option_data.str_value, -1 }

147 };

148

149 option_data.Clear();

150 CommandParsing cmd_parsing(cmd_options, arraysize(cmd_options));

151 ASSERT_FAILED(cmd_parsing.Parse(cmd_line, false));

152 ASSERT_SUCCEEDED(cmd_parsing.Parse(cmd_line, true));

153

154 option_data.bool_value = data.bool_value;

155 CheckTestData(option_data, data);

156 }

157

158 TEST(CommandsTest, NameValuePairCommandLineOptionsParsingTest) {

159 TestData data;

160 FillTestData(&data);

161 CString cmd_line;

162 cmd_line.Format(

163 _T("%s=%s&")

164 _T("%s=%d&")

165 _T("%s=%u&")

166 _T("%s=%s"),

167 kThreeOption, (data.three_value == TRUE_VALUE) ? _T("on") : _T("off"),

168 kIntOption, data.int_value,

169 kUintOption, data.uint_value,

170 kStrOption, data.str_value);

171 if (data.bool_value) {

172 cmd_line.AppendFormat(_T("&%s="), kBoolOption);

173 }

174

175 TestData option_data;

176 CommandOption cmd_options[] = {

177 { kBoolOption, COMMAND_OPTION_BOOL, &option_data.bool_value, -1 },

178 { kThreeOption, COMMAND_OPTION_THREE, &option_data.three_value, -1 },

179 { kIntOption, COMMAND_OPTION_INT, &option_data.int_value, -1 },

180 { kUintOption, COMMAND_OPTION_UINT, &option_data.uint_value, -1 },

181 { kStrOption, COMMAND_OPTION_STRING, &option_data.str_value, -1 }

182 };

183

184 option_data.Clear();

185 CommandParsing cmd_parsing(cmd_options,

186 arraysize(cmd_options),

187 _T('&'),

188 true);

189 ASSERT_SUCCEEDED(cmd_parsing.Parse(cmd_line, false));

190

191 CheckTestData(option_data, data);

192 }

193

194 TEST(CommandsTest, NameValuePairIgnoreUnknownArgsParsingTest) {

195 TestData data;

196 FillTestData(&data);

197 CString cmd_line;

198 cmd_line.Format(

199 _T("%s=%s&")

200 _T("%s=%d&")

201 _T("%s=%u&")

202 _T("%s=%s"),

203 kThreeOption, (data.three_value == TRUE_VALUE) ? _T("on") : _T("off"),

204 kIntOption, data.int_value,

205 kUintOption, data.uint_value,

206 kStrOption, data.str_value);

207 if (data.bool_value) {

208 cmd_line.AppendFormat(_T("&%s="), kBoolOption);

209 }

210

211 TestData option_data;

212 CommandOption cmd_options[] = {

213 { kBoolOption, COMMAND_OPTION_BOOL, &option_data.bool_value, -1 },

214 { kThreeOption, COMMAND_OPTION_THREE, &option_data.three_value, -1 },

215 { kUintOption, COMMAND_OPTION_UINT, &option_data.uint_value, -1 },

216 { kStrOption, COMMAND_OPTION_STRING, &option_data.str_value, -1 }

217 };

218

219 option_data.Clear();

220 CommandParsing cmd_parsing(cmd_options,

221 arraysize(cmd_options),

222 _T('&'),

223 true);

224 ASSERT_FAILED(cmd_parsing.Parse(cmd_line, false));

225 ASSERT_SUCCEEDED(cmd_parsing.Parse(cmd_line, true));

226

227 option_data.int_value = data.int_value;

228 CheckTestData(option_data, data);

229 }

230

231 TEST(CommandsTest, CommandParsingSimpleSplitTest) {

232 CString exe;

233 CString args;

234

235 // Test to make sure SplitExeAndArgs correctly splits

236 // a properly constructed command line

237 ASSERT_SUCCEEDED(

238 CommandParsingSimple::SplitExeAndArgs(kIEBrowserQuotedCommandLine,

239 &exe,

240 &args));

241

242 EXPECT_STREQ(kIEBrowserQuotedExeResult, exe);

243 EXPECT_STREQ(kIEBrowserQuotedArgsResult, args);

244 }

245

246 TEST(CommandsTest, CommandParsingGuessSplitTest) {

247 CString exe;

248 CString args;

249

250 // Test to make sure SplitExeAndArgsGuess correctly splits

251 // a properly constructed command line

252 ASSERT_SUCCEEDED(

253 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserQuotedCommandLine,

254 &exe,

255 &args));

256

257 EXPECT_STREQ(kIEBrowserQuotedExeResult, exe);

258 EXPECT_STREQ(kIEBrowserQuotedArgsResult, args);

259

260 // Test to make sure SplitExeAndArgsGuess correctly splits

261 // an improperly constructed "Uninstall" command line

262 ASSERT_SUCCEEDED(

263 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserUnquotedCommandLine,

264 &exe,

265 &args));

266

267 EXPECT_STREQ(kIEBrowserUnquotedExe, exe);

268 EXPECT_STREQ(kIEBrowserUnquotedArgs, args);

269

270 // Test to make sure SplitExeAndArgsGuess correctly splits

271 // a properly constructed "Uninstall" command line, where

272 // the executable does not have a ".EXE" extension, and

273 // where there happens to be an argument which happens to

274 // be an executable

275 ASSERT_SUCCEEDED(

276 CommandParsingSimple::SplitExeAndArgsGuess(kGEUninstallCommandLine,

277 &exe,

278 &args));

279

280 EXPECT_STREQ(kGEUninstallExe, exe);

281 EXPECT_STREQ(kGEUninstallArgs, args);

282 }

283

284 TEST(CommandsTest, CommandParsingGuessSplit_ExtraWhiteSpace) {

285 CString exe;

286 CString args;

287

288 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

289 kIEBrowserUnquotedCommandLine _T(" "),

290 &exe,

291 &args));

292 EXPECT_STREQ(kIEBrowserUnquotedExe, exe);

293 EXPECT_STREQ(kIEBrowserUnquotedArgs, args);

294

295 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

296 kIEBrowserUnquotedCommandLine _T("\t"),

297 &exe,

298 &args));

299 EXPECT_STREQ(kIEBrowserUnquotedExe, exe);

300 EXPECT_STREQ(kIEBrowserUnquotedArgs, args);

301

302 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

303 _T(" ") kIEBrowserUnquotedCommandLine,

304 &exe,

305 &args));

306 EXPECT_STREQ(kIEBrowserUnquotedExe, exe);

307 EXPECT_STREQ(kIEBrowserUnquotedArgs, args);

308

309 // The following cases have unexpected results.

310 // Quoting a command line with args is not handled correctly.

311 // The entire thing is interpreted as an EXE.

312

313 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

314 _T("\" ") kIEBrowserUnquotedCommandLine _T("\""),

315 &exe,

316 &args));

317 EXPECT_STREQ(kIEBrowserUnquotedCommandLine, exe);

318 EXPECT_TRUE(args.IsEmpty());

319

320 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

321 _T("\"") kIEBrowserUnquotedCommandLine _T(" \""),

322 &exe,

323 &args));

324 EXPECT_STREQ(kIEBrowserUnquotedCommandLine, exe);

325 EXPECT_TRUE(args.IsEmpty());

326

327 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

328 _T("\"") kIEBrowserUnquotedCommandLine _T("\t\""),

329 &exe,

330 &args));

331 EXPECT_STREQ(kIEBrowserUnquotedCommandLine, exe);

332 EXPECT_TRUE(args.IsEmpty());

333 }

334

335 TEST(CommandsTest, CommandParsingGuessSplit_CommandLineIsExistingFile) {

336 CString exe;

337 CString args;

338

339 EXPECT_TRUE(File::Exists(kIEBrowserExe));

340 EXPECT_SUCCEEDED(

341 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserExe, &exe, &args));

342 EXPECT_STREQ(kIEBrowserExe, exe);

343 EXPECT_TRUE(args.IsEmpty());

344

345 // File::Exists does not handle enclosed paths.

346 EXPECT_FALSE(File::Exists(kIEBrowserQuotedExe));

347 EXPECT_SUCCEEDED(

348 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserQuotedExe,

349 &exe,

350 &args));

351 EXPECT_STREQ(kIEBrowserExe, exe);

352 EXPECT_TRUE(args.IsEmpty());

353 }

354

355 TEST(CommandsTest,

356 CommandParsingGuessSplit_CommandLineIsExistingFileWithExtraWhiteSpace) {

357 CString exe;

358 CString args;

359

360 EXPECT_TRUE(File::Exists(kIEBrowserExe));

361 // File::Exists does not handle enclosed paths.

362 EXPECT_FALSE(File::Exists(kIEBrowserQuotedExe));

363

364 EXPECT_SUCCEEDED(

365 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserExe _T(" "),

366 &exe,

367 &args));

368 EXPECT_STREQ(kIEBrowserExe, exe);

369 EXPECT_TRUE(args.IsEmpty());

370

371 EXPECT_SUCCEEDED(

372 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserQuotedExe _T(" "),

373 &exe,

374 &args));

375 EXPECT_STREQ(kIEBrowserExe, exe);

376 EXPECT_TRUE(args.IsEmpty());

377

378 EXPECT_SUCCEEDED(

379 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserExe _T("\t"),

380 &exe,

381 &args));

382 EXPECT_STREQ(kIEBrowserExe, exe);

383 EXPECT_TRUE(args.IsEmpty());

384

385 EXPECT_SUCCEEDED(

386 CommandParsingSimple::SplitExeAndArgsGuess(kIEBrowserQuotedExe _T("\t"),

387 &exe,

388 &args));

389 EXPECT_STREQ(kIEBrowserExe, exe);

390 // SplitExeAndArgs does not treat tab like whitespace and args aren't trimmed.

391 EXPECT_STREQ(_T("\t"), args);

392

393 EXPECT_SUCCEEDED(

394 CommandParsingSimple::SplitExeAndArgsGuess(_T(" ") kIEBrowserExe,

395 &exe,

396 &args));

397 EXPECT_STREQ(kIEBrowserExe, exe);

398 EXPECT_TRUE(args.IsEmpty());

399

400 EXPECT_SUCCEEDED(

401 CommandParsingSimple::SplitExeAndArgsGuess(_T(" ") kIEBrowserQuotedExe,

402 &exe,

403 &args));

404 EXPECT_STREQ(kIEBrowserExe, exe);

405 EXPECT_TRUE(args.IsEmpty());

406

407 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

408 _T("\" ") kIEBrowserExe _T("\""),

409 &exe,

410 &args));

411 EXPECT_STREQ(kIEBrowserExe, exe);

412 EXPECT_TRUE(args.IsEmpty());

413

414 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

415 _T("\"") kIEBrowserExe _T(" \""),

416 &exe,

417 &args));

418 EXPECT_STREQ(kIEBrowserExe, exe);

419 EXPECT_TRUE(args.IsEmpty());

420

421 EXPECT_SUCCEEDED(CommandParsingSimple::SplitExeAndArgsGuess(

422 _T("\"") kIEBrowserExe _T("\t\""),

423 &exe,

424 &args));

425 EXPECT_STREQ(kIEBrowserExe, exe);

426 EXPECT_TRUE(args.IsEmpty());

427 }

428

429 } // namespace omaha

430

OLD	NEW

« no previous file with comments | « base/commands.cc ('k') | base/commontypes.h » ('j') | no next file with comments »