Move allowTrailingOptions into ArgParser.

pkg/args/test/parse_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library parse_test;
 
 import 'package:unittest/unittest.dart';
 import 'package:args/args.dart';
 import 'utils.dart';
 
@@ skipping 35 matching lines @@
         var args = parser.parse([]);
         expect(args['verbose'], isFalse);
       });
 
       test('throws if given a value', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         throwsFormat(parser, ['--verbose=true']);
       });
+
+      test('are case-sensitive', () {
+        var parser = new ArgParser();
+        parser.addFlag('verbose');
+        parser.addFlag('Verbose');
+        var results = parser.parse(['--verbose']);
+        expect(results['verbose'], isTrue);
+        expect(results['Verbose'], isFalse);
+      });
     });
 
     group('flags negated with "no-"', () {
       test('set the flag to false', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         var args = parser.parse(['--no-verbose']);
         expect(args['verbose'], isFalse);
       });
@@ skipping 222 matching lines @@
       });
 
       test('throw if it has a value but the option is a flag', () {
         var parser = new ArgParser();
         parser.addFlag('apple', abbr: 'a');
         parser.addFlag('banana', abbr: 'b');
 
         // The '?!' means this can only be understood as '--apple b?!c'.
         throwsFormat(parser, ['-ab?!c']);
       });
+
+      test('are case-sensitive', () {
+        var parser = new ArgParser();
+        parser.addFlag('file', abbr: 'f');
+        parser.addFlag('force', abbr: 'F');
+        var results = parser.parse(['-f']);
+        expect(results['file'], isTrue);
+        expect(results['force'], isFalse);
+      });
     });
 
     group('options', () {
       test('are parsed if present', () {
         var parser = new ArgParser();
         parser.addOption('mode');
         var args = parser.parse(['--mode=release']);
         expect(args['mode'], equals('release'));
       });
 
@@ skipping 69 matching lines @@
         expect(args['define'], equals(['1','2']));
       });
 
       test('returns the default value for multi-valued arguments '
            'if not explicitly set', () {
         var parser = new ArgParser();
         parser.addOption('define', defaultsTo: '0', allowMultiple: true);
         var args = parser.parse(['']);
         expect(args['define'], equals(['0']));
       });
+
+      test('are case-sensitive', () {
+        var parser = new ArgParser();
+        parser.addOption('verbose', defaultsTo: 'no');
+        parser.addOption('Verbose', defaultsTo: 'no');
+        var results = parser.parse(['--verbose', 'chatty']);
+        expect(results['verbose'], equals('chatty'));
+        expect(results['Verbose'], equals('no'));
+      });
     });
 
     group('remaining args', () {
       test('stops parsing args when a non-option-like arg is encountered', () {
         var parser = new ArgParser();
         parser.addFlag('woof');
         parser.addOption('meow');
         parser.addOption('tweet', defaultsTo: 'bird');
 
         var results = parser.parse(['--woof', '--meow', 'v', 'not', 'option']);
         expect(results['woof'], isTrue);
         expect(results['meow'], equals('v'));
         expect(results['tweet'], equals('bird'));
-        expect(results.rest, orderedEquals(['not', 'option']));
+        expect(results.rest, equals(['not', 'option']));
       });
 
-      test('stops parsing at "--"', () {
+      test('consumes "--" and stops', () {
         var parser = new ArgParser();
         parser.addFlag('woof', defaultsTo: false);
         parser.addOption('meow', defaultsTo: 'kitty');
 
         var results = parser.parse(['--woof', '--', '--meow']);
         expect(results['woof'], isTrue);
         expect(results['meow'], equals('kitty'));
-        expect(results.rest, orderedEquals(['--meow']));
+        expect(results.rest, equals(['--meow']));
       });
 
-      test('handles options with case-sensitivity', () {
+      test('leaves "--" if not the first non-option', () {
         var parser = new ArgParser();
-        parser.addFlag('recurse', defaultsTo: false, abbr:'R');
-        var results = parser.parse(['-R']);
-        expect(results['recurse'], isTrue);
-        expect(results.rest, [ ]);
-        throwsFormat(parser, ['-r']);
+        parser.addFlag('woof');
+
+        var results = parser.parse(['--woof', 'stop', '--', 'arg']);
+        expect(results['woof'], isTrue);
+        expect(results.rest, equals(['stop', '--', 'arg']));
       });
     });
   });
 }