format code, removed unused variables and deprecated usage

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 87 matching lines @@
         throwsFormat(parser, ['--no-strum']);
       });
     });
 
     group('callbacks', () {
       test('for present flags are invoked with the value', () {
         var a;
         var parser = new ArgParser();
         parser.addFlag('a', callback: (value) => a = value);
 
-        var args = parser.parse(['--a']);
+        parser.parse(['--a']);
         expect(a, isTrue);
       });
 
       test('for absent flags are invoked with the default value', () {
         var a;
         var parser = new ArgParser();
-        parser.addFlag('a', defaultsTo: false,
-            callback: (value) => a = value);
+        parser.addFlag('a', defaultsTo: false, callback: (value) => a = value);
 
-        var args = parser.parse([]);
+        parser.parse([]);
         expect(a, isFalse);
       });
 
       test('are invoked even if the flag is not present', () {
         var a = 'not called';
         var parser = new ArgParser();
         parser.addFlag('a', callback: (value) => a = value);
 
-        var args = parser.parse([]);
+        parser.parse([]);
         expect(a, isFalse);
       });
 
       test('for present options are invoked with the value', () {
         var a;
         var parser = new ArgParser();
         parser.addOption('a', callback: (value) => a = value);
 
-        var args = parser.parse(['--a=v']);
+        parser.parse(['--a=v']);
         expect(a, equals('v'));
       });
 
       test('for absent options are invoked with the default value', () {
         var a;
         var parser = new ArgParser();
-        parser.addOption('a', defaultsTo: 'v',
-            callback: (value) => a = value);
+        parser.addOption('a', defaultsTo: 'v', callback: (value) => a = value);
 
-        var args = parser.parse([]);
+        parser.parse([]);
         expect(a, equals('v'));
       });
 
       test('are invoked even if the option is not present', () {
         var a = 'not called';
         var parser = new ArgParser();
         parser.addOption('a', callback: (value) => a = value);
 
-        var args = parser.parse([]);
+        parser.parse([]);
         expect(a, isNull);
       });
 
       test('for multiple present, allowMultiple, options are invoked with '
-           'value as a list', () {
+          'value as a list', () {
         var a;
         var parser = new ArgParser();
-        parser.addOption('a', allowMultiple: true,
-            callback: (value) => a = value);
+        parser.addOption('a',
+            allowMultiple: true, callback: (value) => a = value);
 
-        var args = parser.parse(['--a=v', '--a=x']);
+        parser.parse(['--a=v', '--a=x']);
         expect(a, equals(['v', 'x']));
       });
 
       test('for single present, allowMultiple, options are invoked with '
-           ' value as a single element list', () {
+          ' value as a single element list', () {
         var a;
         var parser = new ArgParser();
-        parser.addOption('a', allowMultiple: true,
-            callback: (value) => a = value);
+        parser.addOption('a',
+            allowMultiple: true, callback: (value) => a = value);
 
-        var args = parser.parse(['--a=v']);
+        parser.parse(['--a=v']);
         expect(a, equals(['v']));
       });
 
       test('for absent, allowMultiple, options are invoked with default '
-           'value as a list.', () {
+          'value as a list.', () {
         var a;
         var parser = new ArgParser();
-        parser.addOption('a', allowMultiple: true, defaultsTo: 'v',
+        parser.addOption('a',
+            allowMultiple: true,
+            defaultsTo: 'v',
             callback: (value) => a = value);
 
-        var args = parser.parse([]);
+        parser.parse([]);
         expect(a, equals(['v']));
       });
 
       test('for absent, allowMultiple, options are invoked with value '
-           'as an empty list.', () {
+          'as an empty list.', () {
         var a;
         var parser = new ArgParser();
-        parser.addOption('a', allowMultiple: true,
-            callback: (value) => a = value);
+        parser.addOption('a',
+            allowMultiple: true, callback: (value) => a = value);
 
-        var args = parser.parse([]);
+        parser.parse([]);
         expect(a, isEmpty);
       });
     });
 
     group('abbreviations', () {
       test('are parsed with a preceding "-"', () {
         var parser = new ArgParser();
         parser.addFlag('arg', abbr: 'a');
 
         var args = parser.parse(['-a']);
@@ skipping 175 matching lines @@
         var args = parser.parse(['--define=1', '--define=2']);
         expect(args['define'], equals('2'));
       });
 
       test('returns a List if multi-valued', () {
         var parser = new ArgParser();
         parser.addOption('define', allowMultiple: true);
         var args = parser.parse(['--define=1']);
         expect(args['define'], equals(['1']));
         args = parser.parse(['--define=1', '--define=2']);
-        expect(args['define'], equals(['1','2']));
+        expect(args['define'], equals(['1', '2']));
       });
 
       test('returns the default value for multi-valued arguments '
-           'if not explicitly set', () {
+          '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');
@@ skipping 32 matching lines @@
         var parser = new ArgParser();
         parser.addFlag('woof');
 
         var results = parser.parse(['--woof', 'stop', '--', 'arg']);
         expect(results['woof'], isTrue);
         expect(results.rest, equals(['stop', '--', 'arg']));
       });
     });
   });
 }