OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #library('args_test'); | 5 #library('args_test'); |
6 | 6 |
7 #import('../../../lib/unittest/unittest.dart'); | 7 #import('../../../lib/unittest/unittest.dart'); |
8 #import('../../../lib/args/args.dart'); | 8 #import('../../../lib/args/args.dart'); |
9 | 9 |
10 main() { | 10 main() { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
60 }); | 60 }); |
61 }); | 61 }); |
62 | 62 |
63 group('ArgParser.parse()', () { | 63 group('ArgParser.parse()', () { |
64 group('flags', () { | 64 group('flags', () { |
65 test('are true if present', () { | 65 test('are true if present', () { |
66 var parser = new ArgParser(); | 66 var parser = new ArgParser(); |
67 parser.addFlag('verbose'); | 67 parser.addFlag('verbose'); |
68 | 68 |
69 var args = parser.parse(['--verbose']); | 69 var args = parser.parse(['--verbose']); |
70 expect(args['verbose']).isTrue(); | 70 expect(args['verbose'], isTrue); |
71 }); | 71 }); |
72 | 72 |
73 test('default if missing', () { | 73 test('default if missing', () { |
74 var parser = new ArgParser(); | 74 var parser = new ArgParser(); |
75 parser.addFlag('a', defaultsTo: true); | 75 parser.addFlag('a', defaultsTo: true); |
76 parser.addFlag('b', defaultsTo: false); | 76 parser.addFlag('b', defaultsTo: false); |
77 | 77 |
78 var args = parser.parse([]); | 78 var args = parser.parse([]); |
79 expect(args['a']).isTrue(); | 79 expect(args['a'], isTrue); |
80 expect(args['b']).isFalse(); | 80 expect(args['b'], isFalse); |
81 }); | 81 }); |
82 | 82 |
83 test('are false if missing with no default', () { | 83 test('are false if missing with no default', () { |
84 var parser = new ArgParser(); | 84 var parser = new ArgParser(); |
85 parser.addFlag('verbose'); | 85 parser.addFlag('verbose'); |
86 | 86 |
87 var args = parser.parse([]); | 87 var args = parser.parse([]); |
88 expect(args['verbose']).isFalse(); | 88 expect(args['verbose'], isFalse); |
89 }); | 89 }); |
90 | 90 |
91 test('throws if given a value', () { | 91 test('throws if given a value', () { |
92 var parser = new ArgParser(); | 92 var parser = new ArgParser(); |
93 parser.addFlag('verbose'); | 93 parser.addFlag('verbose'); |
94 | 94 |
95 throwsBadFormat(parser, ['--verbose=true']); | 95 throwsBadFormat(parser, ['--verbose=true']); |
96 }); | 96 }); |
97 }); | 97 }); |
98 | 98 |
99 group('flags negated with "no-"', () { | 99 group('flags negated with "no-"', () { |
100 test('set the flag to false', () { | 100 test('set the flag to false', () { |
101 var parser = new ArgParser(); | 101 var parser = new ArgParser(); |
102 parser.addFlag('verbose'); | 102 parser.addFlag('verbose'); |
103 | 103 |
104 var args = parser.parse(['--no-verbose']); | 104 var args = parser.parse(['--no-verbose']); |
105 expect(args['verbose']).isFalse(); | 105 expect(args['verbose'], isFalse); |
106 }); | 106 }); |
107 | 107 |
108 test('set the flag to true if the flag actually starts with "no-"', () { | 108 test('set the flag to true if the flag actually starts with "no-"', () { |
109 var parser = new ArgParser(); | 109 var parser = new ArgParser(); |
110 parser.addFlag('no-body'); | 110 parser.addFlag('no-body'); |
111 | 111 |
112 var args = parser.parse(['--no-body']); | 112 var args = parser.parse(['--no-body']); |
113 expect(args['no-body']).isTrue(); | 113 expect(args['no-body'], isTrue); |
114 }); | 114 }); |
115 | 115 |
116 test('are not preferred over a colliding one without', () { | 116 test('are not preferred over a colliding one without', () { |
117 var parser = new ArgParser(); | 117 var parser = new ArgParser(); |
118 parser.addFlag('no-strum'); | 118 parser.addFlag('no-strum'); |
119 parser.addFlag('strum'); | 119 parser.addFlag('strum'); |
120 | 120 |
121 var args = parser.parse(['--no-strum']); | 121 var args = parser.parse(['--no-strum']); |
122 expect(args['no-strum']).isTrue(); | 122 expect(args['no-strum'], isTrue); |
123 expect(args['strum']).isFalse(); | 123 expect(args['strum'], isFalse); |
124 }); | 124 }); |
125 }); | 125 }); |
126 | 126 |
127 group('callbacks', () { | 127 group('callbacks', () { |
128 test('for present flags are invoked with the value', () { | 128 test('for present flags are invoked with the value', () { |
129 var a; | 129 var a; |
130 var parser = new ArgParser(); | 130 var parser = new ArgParser(); |
131 parser.addFlag('a', callback: (value) => a = value); | 131 parser.addFlag('a', callback: (value) => a = value); |
132 | 132 |
133 var args = parser.parse(['--a']); | 133 var args = parser.parse(['--a']); |
134 expect(a).isTrue(); | 134 expect(a, isTrue); |
135 }); | 135 }); |
136 | 136 |
137 test('for absent flags are invoked with the default value', () { | 137 test('for absent flags are invoked with the default value', () { |
138 var a; | 138 var a; |
139 var parser = new ArgParser(); | 139 var parser = new ArgParser(); |
140 parser.addFlag('a', defaultsTo: false, | 140 parser.addFlag('a', defaultsTo: false, |
141 callback: (value) => a = value); | 141 callback: (value) => a = value); |
142 | 142 |
143 var args = parser.parse([]); | 143 var args = parser.parse([]); |
144 expect(a).isFalse(); | 144 expect(a, isFalse); |
145 }); | 145 }); |
146 | 146 |
147 test('are invoked even if the flag is not present', () { | 147 test('are invoked even if the flag is not present', () { |
148 var a = 'not called'; | 148 var a = 'not called'; |
149 var parser = new ArgParser(); | 149 var parser = new ArgParser(); |
150 parser.addFlag('a', callback: (value) => a = value); | 150 parser.addFlag('a', callback: (value) => a = value); |
151 | 151 |
152 var args = parser.parse([]); | 152 var args = parser.parse([]); |
153 expect(a).isFalse(); | 153 expect(a, isFalse); |
154 }); | 154 }); |
155 | 155 |
156 test('for present options are invoked with the value', () { | 156 test('for present options are invoked with the value', () { |
157 var a; | 157 var a; |
158 var parser = new ArgParser(); | 158 var parser = new ArgParser(); |
159 parser.addOption('a', callback: (value) => a = value); | 159 parser.addOption('a', callback: (value) => a = value); |
160 | 160 |
161 var args = parser.parse(['--a=v']); | 161 var args = parser.parse(['--a=v']); |
162 expect(a).equals('v'); | 162 expect(a, equals('v')); |
163 }); | 163 }); |
164 | 164 |
165 test('for absent options are invoked with the default value', () { | 165 test('for absent options are invoked with the default value', () { |
166 var a; | 166 var a; |
167 var parser = new ArgParser(); | 167 var parser = new ArgParser(); |
168 parser.addOption('a', defaultsTo: 'v', | 168 parser.addOption('a', defaultsTo: 'v', |
169 callback: (value) => a = value); | 169 callback: (value) => a = value); |
170 | 170 |
171 var args = parser.parse([]); | 171 var args = parser.parse([]); |
172 expect(a).equals('v'); | 172 expect(a, equals('v')); |
173 }); | 173 }); |
174 | 174 |
175 test('are invoked even if the option is not present', () { | 175 test('are invoked even if the option is not present', () { |
176 var a = 'not called'; | 176 var a = 'not called'; |
177 var parser = new ArgParser(); | 177 var parser = new ArgParser(); |
178 parser.addOption('a', callback: (value) => a = value); | 178 parser.addOption('a', callback: (value) => a = value); |
179 | 179 |
180 var args = parser.parse([]); | 180 var args = parser.parse([]); |
181 expect(a).isNull(); | 181 expect(a, isNull); |
182 }); | 182 }); |
183 }); | 183 }); |
184 | 184 |
185 group('abbreviations', () { | 185 group('abbreviations', () { |
186 test('are parsed with a preceding "-"', () { | 186 test('are parsed with a preceding "-"', () { |
187 var parser = new ArgParser(); | 187 var parser = new ArgParser(); |
188 parser.addFlag('arg', abbr: 'a'); | 188 parser.addFlag('arg', abbr: 'a'); |
189 | 189 |
190 var args = parser.parse(['-a']); | 190 var args = parser.parse(['-a']); |
191 expect(args['arg']).isTrue(); | 191 expect(args['arg'], isTrue); |
192 }); | 192 }); |
193 | 193 |
194 test('can use multiple after a single "-"', () { | 194 test('can use multiple after a single "-"', () { |
195 var parser = new ArgParser(); | 195 var parser = new ArgParser(); |
196 parser.addFlag('first', abbr: 'f'); | 196 parser.addFlag('first', abbr: 'f'); |
197 parser.addFlag('second', abbr: 's'); | 197 parser.addFlag('second', abbr: 's'); |
198 parser.addFlag('third', abbr: 't'); | 198 parser.addFlag('third', abbr: 't'); |
199 | 199 |
200 var args = parser.parse(['-tf']); | 200 var args = parser.parse(['-tf']); |
201 expect(args['first']).isTrue(); | 201 expect(args['first'], isTrue); |
202 expect(args['second']).isFalse(); | 202 expect(args['second'], isFalse); |
203 expect(args['third']).isTrue(); | 203 expect(args['third'], isTrue); |
204 }); | 204 }); |
205 | 205 |
206 test('can have multiple "-" args', () { | 206 test('can have multiple "-" args', () { |
207 var parser = new ArgParser(); | 207 var parser = new ArgParser(); |
208 parser.addFlag('first', abbr: 'f'); | 208 parser.addFlag('first', abbr: 'f'); |
209 parser.addFlag('second', abbr: 's'); | 209 parser.addFlag('second', abbr: 's'); |
210 parser.addFlag('third', abbr: 't'); | 210 parser.addFlag('third', abbr: 't'); |
211 | 211 |
212 var args = parser.parse(['-s', '-tf']); | 212 var args = parser.parse(['-s', '-tf']); |
213 expect(args['first']).isTrue(); | 213 expect(args['first'], isTrue); |
214 expect(args['second']).isTrue(); | 214 expect(args['second'], isTrue); |
215 expect(args['third']).isTrue(); | 215 expect(args['third'], isTrue); |
216 }); | 216 }); |
217 | 217 |
218 test('can take arguments without a space separating', () { | 218 test('can take arguments without a space separating', () { |
219 var parser = new ArgParser(); | 219 var parser = new ArgParser(); |
220 parser.addOption('file', abbr: 'f'); | 220 parser.addOption('file', abbr: 'f'); |
221 | 221 |
222 var args = parser.parse(['-flip']); | 222 var args = parser.parse(['-flip']); |
223 expect(args['file']).equals('lip'); | 223 expect(args['file'], equals('lip')); |
224 }); | 224 }); |
225 | 225 |
226 test('can take arguments with a space separating', () { | 226 test('can take arguments with a space separating', () { |
227 var parser = new ArgParser(); | 227 var parser = new ArgParser(); |
228 parser.addOption('file', abbr: 'f'); | 228 parser.addOption('file', abbr: 'f'); |
229 | 229 |
230 var args = parser.parse(['-f', 'name']); | 230 var args = parser.parse(['-f', 'name']); |
231 expect(args['file']).equals('name'); | 231 expect(args['file'], equals('name')); |
232 }); | 232 }); |
233 | 233 |
234 test('allow non-option characters in the value', () { | 234 test('allow non-option characters in the value', () { |
235 var parser = new ArgParser(); | 235 var parser = new ArgParser(); |
236 parser.addOption('apple', abbr: 'a'); | 236 parser.addOption('apple', abbr: 'a'); |
237 | 237 |
238 var args = parser.parse(['-ab?!c']); | 238 var args = parser.parse(['-ab?!c']); |
239 expect(args['apple']).equals('b?!c'); | 239 expect(args['apple'], equals('b?!c')); |
240 }); | 240 }); |
241 | 241 |
242 test('throw if unknown', () { | 242 test('throw if unknown', () { |
243 var parser = new ArgParser(); | 243 var parser = new ArgParser(); |
244 throwsBadFormat(parser, ['-f']); | 244 throwsBadFormat(parser, ['-f']); |
245 }); | 245 }); |
246 | 246 |
247 test('throw if the value is missing', () { | 247 test('throw if the value is missing', () { |
248 var parser = new ArgParser(); | 248 var parser = new ArgParser(); |
249 parser.addOption('file', abbr: 'f'); | 249 parser.addOption('file', abbr: 'f'); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
285 // The '?!' means this can only be understood as '--apple b?!c'. | 285 // The '?!' means this can only be understood as '--apple b?!c'. |
286 throwsBadFormat(parser, ['-ab?!c']); | 286 throwsBadFormat(parser, ['-ab?!c']); |
287 }); | 287 }); |
288 }); | 288 }); |
289 | 289 |
290 group('options', () { | 290 group('options', () { |
291 test('are parsed if present', () { | 291 test('are parsed if present', () { |
292 var parser = new ArgParser(); | 292 var parser = new ArgParser(); |
293 parser.addOption('mode'); | 293 parser.addOption('mode'); |
294 var args = parser.parse(['--mode=release']); | 294 var args = parser.parse(['--mode=release']); |
295 expect(args['mode']).equals('release'); | 295 expect(args['mode'], equals('release')); |
296 }); | 296 }); |
297 | 297 |
298 test('are null if not present', () { | 298 test('are null if not present', () { |
299 var parser = new ArgParser(); | 299 var parser = new ArgParser(); |
300 parser.addOption('mode'); | 300 parser.addOption('mode'); |
301 var args = parser.parse([]); | 301 var args = parser.parse([]); |
302 expect(args['mode']).isNull(); | 302 expect(args['mode'], isNull); |
303 }); | 303 }); |
304 | 304 |
305 test('default if missing', () { | 305 test('default if missing', () { |
306 var parser = new ArgParser(); | 306 var parser = new ArgParser(); |
307 parser.addOption('mode', defaultsTo: 'debug'); | 307 parser.addOption('mode', defaultsTo: 'debug'); |
308 var args = parser.parse([]); | 308 var args = parser.parse([]); |
309 expect(args['mode']).equals('debug'); | 309 expect(args['mode'], equals('debug')); |
310 }); | 310 }); |
311 | 311 |
312 test('allow the value to be separated by whitespace', () { | 312 test('allow the value to be separated by whitespace', () { |
313 var parser = new ArgParser(); | 313 var parser = new ArgParser(); |
314 parser.addOption('mode'); | 314 parser.addOption('mode'); |
315 var args = parser.parse(['--mode', 'release']); | 315 var args = parser.parse(['--mode', 'release']); |
316 expect(args['mode']).equals('release'); | 316 expect(args['mode'], equals('release')); |
317 }); | 317 }); |
318 | 318 |
319 test('throw if unknown', () { | 319 test('throw if unknown', () { |
320 var parser = new ArgParser(); | 320 var parser = new ArgParser(); |
321 throwsBadFormat(parser, ['--unknown']); | 321 throwsBadFormat(parser, ['--unknown']); |
322 throwsBadFormat(parser, ['--nobody']); // Starts with "no". | 322 throwsBadFormat(parser, ['--nobody']); // Starts with "no". |
323 }); | 323 }); |
324 | 324 |
325 test('throw if the arg does not include a value', () { | 325 test('throw if the arg does not include a value', () { |
326 var parser = new ArgParser(); | 326 var parser = new ArgParser(); |
327 parser.addOption('mode'); | 327 parser.addOption('mode'); |
328 throwsBadFormat(parser, ['--mode']); | 328 throwsBadFormat(parser, ['--mode']); |
329 }); | 329 }); |
330 | 330 |
331 test('throw if the value looks like an option', () { | 331 test('throw if the value looks like an option', () { |
332 var parser = new ArgParser(); | 332 var parser = new ArgParser(); |
333 parser.addOption('mode'); | 333 parser.addOption('mode'); |
334 parser.addOption('other'); | 334 parser.addOption('other'); |
335 | 335 |
336 throwsBadFormat(parser, ['--mode', '--other']); | 336 throwsBadFormat(parser, ['--mode', '--other']); |
337 throwsBadFormat(parser, ['--mode', '--unknown']); | 337 throwsBadFormat(parser, ['--mode', '--unknown']); |
338 throwsBadFormat(parser, ['--mode', '-abbr']); | 338 throwsBadFormat(parser, ['--mode', '-abbr']); |
339 }); | 339 }); |
340 | 340 |
341 test('do not throw if the value is in the allowed set', () { | 341 test('do not throw if the value is in the allowed set', () { |
342 var parser = new ArgParser(); | 342 var parser = new ArgParser(); |
343 parser.addOption('mode', allowed: ['debug', 'release']); | 343 parser.addOption('mode', allowed: ['debug', 'release']); |
344 var args = parser.parse(['--mode=debug']); | 344 var args = parser.parse(['--mode=debug']); |
345 expect(args['mode']).equals('debug'); | 345 expect(args['mode'], equals('debug')); |
346 }); | 346 }); |
347 | 347 |
348 test('throw if the value is not in the allowed set', () { | 348 test('throw if the value is not in the allowed set', () { |
349 var parser = new ArgParser(); | 349 var parser = new ArgParser(); |
350 parser.addOption('mode', allowed: ['debug', 'release']); | 350 parser.addOption('mode', allowed: ['debug', 'release']); |
351 throwsBadFormat(parser, ['--mode=profile']); | 351 throwsBadFormat(parser, ['--mode=profile']); |
352 }); | 352 }); |
353 }); | 353 }); |
354 | 354 |
355 group('remaining args', () { | 355 group('remaining args', () { |
356 test('stops parsing args when a non-option-like arg is encountered', () { | 356 test('stops parsing args when a non-option-like arg is encountered', () { |
357 var parser = new ArgParser(); | 357 var parser = new ArgParser(); |
358 parser.addFlag('woof'); | 358 parser.addFlag('woof'); |
359 parser.addOption('meow'); | 359 parser.addOption('meow'); |
360 parser.addOption('tweet', defaultsTo: 'bird'); | 360 parser.addOption('tweet', defaultsTo: 'bird'); |
361 | 361 |
362 var results = parser.parse(['--woof', '--meow', 'v', 'not', 'option']); | 362 var results = parser.parse(['--woof', '--meow', 'v', 'not', 'option']); |
363 expect(results['woof']).isTrue(); | 363 expect(results['woof'], isTrue); |
364 expect(results['meow']).equals('v'); | 364 expect(results['meow'], equals('v')); |
365 expect(results['tweet']).equals('bird'); | 365 expect(results['tweet'], equals('bird')); |
366 expect(results.rest).equalsCollection(['not', 'option']); | 366 expect(results.rest, orderedEquals(['not', 'option'])); |
367 }); | 367 }); |
368 | 368 |
369 test('stops parsing at "--"', () { | 369 test('stops parsing at "--"', () { |
370 var parser = new ArgParser(); | 370 var parser = new ArgParser(); |
371 parser.addFlag('woof', defaultsTo: false); | 371 parser.addFlag('woof', defaultsTo: false); |
372 parser.addOption('meow', defaultsTo: 'kitty'); | 372 parser.addOption('meow', defaultsTo: 'kitty'); |
373 | 373 |
374 var results = parser.parse(['--woof', '--', '--meow']); | 374 var results = parser.parse(['--woof', '--', '--meow']); |
375 expect(results['woof']).isTrue(); | 375 expect(results['woof'], isTrue); |
376 expect(results['meow']).equals('kitty'); | 376 expect(results['meow'], equals('kitty')); |
377 expect(results.rest).equalsCollection(['--meow']); | 377 expect(results.rest, orderedEquals(['--meow'])); |
378 }); | 378 }); |
379 }); | 379 }); |
380 }); | 380 }); |
381 | 381 |
382 group('ArgParser.getUsage()', () { | 382 group('ArgParser.getUsage()', () { |
383 test('flags show "no-" in title', () { | 383 test('flags show "no-" in title', () { |
384 var parser = new ArgParser(); | 384 var parser = new ArgParser(); |
385 parser.addFlag('mode', help: 'The mode'); | 385 parser.addFlag('mode', help: 'The mode'); |
386 | 386 |
387 validateUsage(parser, | 387 validateUsage(parser, |
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
533 group('ArgResults[]', () { | 533 group('ArgResults[]', () { |
534 test('throws if the name is not an option', () { | 534 test('throws if the name is not an option', () { |
535 var parser = new ArgParser(); | 535 var parser = new ArgParser(); |
536 var results = parser.parse([]); | 536 var results = parser.parse([]); |
537 throwsIllegalArg(() => results['unknown']); | 537 throwsIllegalArg(() => results['unknown']); |
538 }); | 538 }); |
539 }); | 539 }); |
540 } | 540 } |
541 | 541 |
542 throwsIllegalArg(function) { | 542 throwsIllegalArg(function) { |
543 expectThrow(function, (e) => e is IllegalArgumentException); | 543 expect(function, throwsA(new isInstanceOf<IllegalArgumentException>())); |
544 } | 544 } |
545 | 545 |
546 throwsBadFormat(ArgParser parser, List<String> args) { | 546 throwsBadFormat(ArgParser parser, List<String> args) { |
547 expectThrow(() => parser.parse(args), (e) => e is ArgFormatException); | 547 expect(() => parser.parse(args), |
| 548 throwsA(new isInstanceOf<ArgFormatException>())); |
548 } | 549 } |
549 | 550 |
550 validateUsage(ArgParser parser, String expected) { | 551 validateUsage(ArgParser parser, String expected) { |
551 expected = unindentString(expected); | 552 expected = unindentString(expected); |
552 expect(parser.getUsage()).equals(expected); | 553 expect(parser.getUsage(), equals(expected)); |
553 } | 554 } |
554 | 555 |
555 // TODO(rnystrom): Replace one in test_utils. | 556 // TODO(rnystrom): Replace one in test_utils. |
556 String unindentString(String text) { | 557 String unindentString(String text) { |
557 var lines = text.split('\n'); | 558 var lines = text.split('\n'); |
558 | 559 |
559 // Count the indentation of the last line. | 560 // Count the indentation of the last line. |
560 var whitespace = const RegExp('^ *'); | 561 var whitespace = const RegExp('^ *'); |
561 var indent = whitespace.firstMatch(lines[lines.length - 1])[0].length; | 562 var indent = whitespace.firstMatch(lines[lines.length - 1])[0].length; |
562 | 563 |
(...skipping 16 matching lines...) Expand all Loading... |
579 throw new IllegalArgumentException( | 580 throw new IllegalArgumentException( |
580 'Line "$line" does not have enough indentation.'); | 581 'Line "$line" does not have enough indentation.'); |
581 } | 582 } |
582 | 583 |
583 lines[i] = line.substring(indent); | 584 lines[i] = line.substring(indent); |
584 } | 585 } |
585 } | 586 } |
586 | 587 |
587 return Strings.join(lines, '\n'); | 588 return Strings.join(lines, '\n'); |
588 } | 589 } |
OLD | NEW |