Autoformat tools/testing/dart

tools/testing/dart/status_file_parser.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 status_file_parser;
 
 import "dart:async";
 import "dart:convert" show LineSplitter, UTF8;
 import "dart:io";
 
 import "path.dart";
 import "status_expression.dart";
 
 class Expectation {
   // Possible outcomes of running a test.
   static Expectation PASS = byName('Pass');
   static Expectation CRASH = byName('Crash');
   static Expectation TIMEOUT = byName('Timeout');
   static Expectation FAIL = byName('Fail');
 
   // Special 'FAIL' cases
   static Expectation RUNTIME_ERROR = byName('RuntimeError');
   static Expectation COMPILETIME_ERROR = byName('CompileTimeError');
   static Expectation MISSING_RUNTIME_ERROR = byName('MissingRuntimeError');
   static Expectation MISSING_COMPILETIME_ERROR =
       byName('MissingCompileTimeError');
   static Expectation STATIC_WARNING = byName('StaticWarning');
-  static Expectation MISSING_STATIC_WARNING =
-      byName('MissingStaticWarning');
+  static Expectation MISSING_STATIC_WARNING = byName('MissingStaticWarning');
   static Expectation PUB_GET_ERROR = byName('PubGetError');
 
   // "meta expectations"
   static Expectation OK = byName('Ok');
   static Expectation SLOW = byName('Slow');
   static Expectation SKIP = byName('Skip');
   static Expectation SKIP_SLOW = byName('SkipSlow');
   static Expectation SKIP_BY_DESIGN = byName('SkipByDesign');
 
   static Expectation byName(String name) {
     _initialize();
     name = name.toLowerCase();
     if (!_AllExpectations.containsKey(name)) {
       throw new Exception("Expectation.byName(name='$name'): Invalid name.");
     }
     return _AllExpectations[name];
   }
 
   // Keep a map of all possible Expectation objects, initialized lazily.
-  static Map<String, Expectation>  _AllExpectations;
+  static Map<String, Expectation> _AllExpectations;
   static void _initialize() {
     if (_AllExpectations == null) {
       _AllExpectations = new Map<String, Expectation>();
 
       Expectation build(prettyName, {group: null, isMetaExpectation: false}) {
         var expectation = new Expectation._(prettyName,
             group: group, isMetaExpectation: isMetaExpectation);
         assert(!_AllExpectations.containsKey(expectation.name));
         return _AllExpectations[expectation.name] = expectation;
       }
@@ skipping 22 matching lines @@
   }
 
   final String prettyName;
   final String name;
   final Expectation group;
   // Indicates whether this expectation cannot be a test outcome (i.e. it is a
   // "meta marker").
   final bool isMetaExpectation;
 
   Expectation._(prettyName,
-                {Expectation this.group: null,
-                 bool this.isMetaExpectation: false})
-      : prettyName = prettyName, name = prettyName.toLowerCase();
+      {Expectation this.group: null, bool this.isMetaExpectation: false})
+      : prettyName = prettyName,
+        name = prettyName.toLowerCase();
 
   bool canBeOutcomeOf(Expectation expectation) {
     Expectation outcome = this;
     while (outcome != null) {
       if (outcome == expectation) {
         return true;
       }
       outcome = outcome.group;
     }
     return false;
   }
 
   String toString() => prettyName;
 }
 
-
 final RegExp SplitComment = new RegExp("^([^#]*)(#.*)?\$");
 final RegExp HeaderPattern = new RegExp(r"^\[([^\]]+)\]");
 final RegExp RulePattern = new RegExp(r"\s*([^: ]*)\s*:(.*)");
 final RegExp IssueNumberPattern = new RegExp("[Ii]ssue ([0-9]+)");
 
 class StatusFile {
   final Path location;
 
   StatusFile(this.location);
 }
 
 // TODO(whesse): Implement configuration_info library that contains data
 // structures for test configuration, including Section.
 class Section {
   final StatusFile statusFile;
 
   final BooleanExpression condition;
   final List<TestRule> testRules;
   final int lineNumber;
 
   Section.always(this.statusFile, this.lineNumber)
-      : condition = null, testRules = new List<TestRule>();
+      : condition = null,
+        testRules = new List<TestRule>();
   Section(this.statusFile, this.condition, this.lineNumber)
       : testRules = new List<TestRule>();
 
   bool isEnabled(environment) =>
       condition == null || condition.evaluate(environment);
 
   String toString() {
     return "Section: $condition";
   }
 }
 
-Future<TestExpectations> ReadTestExpectations(List<String> statusFilePaths,
-                                              Map environment) {
+Future<TestExpectations> ReadTestExpectations(
+    List<String> statusFilePaths, Map environment) {
   var testExpectations = new TestExpectations();
   return Future.wait(statusFilePaths.map((String statusFile) {
-    return ReadTestExpectationsInto(
-        testExpectations, statusFile, environment);
+    return ReadTestExpectationsInto(testExpectations, statusFile, environment);
   })).then((_) => testExpectations);
 }
 
-Future ReadTestExpectationsInto(TestExpectations expectations,
-                                String statusFilePath,
-                                environment) {
+Future ReadTestExpectationsInto(
+    TestExpectations expectations, String statusFilePath, environment) {
   var completer = new Completer();
   List<Section> sections = new List<Section>();
 
   void sectionsRead() {
     for (Section section in sections) {
       if (section.isEnabled(environment)) {
         for (var rule in section.testRules) {
           expectations.addRule(rule, environment);
         }
       }
     }
     completer.complete();
   }
 
   ReadConfigurationInto(new Path(statusFilePath), sections, sectionsRead);
   return completer.future;
 }
 
 void ReadConfigurationInto(Path path, sections, onDone) {
   StatusFile statusFile = new StatusFile(path);
   File file = new File(path.toNativePath());
   if (!file.existsSync()) {
     throw new Exception('Cannot find test status file $path');
   }
   int lineNumber = 0;
   Stream<String> lines =
-      file.openRead()
-          .transform(UTF8.decoder)
-          .transform(new LineSplitter());
+      file.openRead().transform(UTF8.decoder).transform(new LineSplitter());
 
   Section currentSection = new Section.always(statusFile, -1);
   sections.add(currentSection);
 
-
   lines.listen((String line) {
     lineNumber++;
     Match match = SplitComment.firstMatch(line);
     line = (match == null) ? "" : match[1];
     line = line.trim();
     if (line.isEmpty) return;
 
     // Extract the comment to get the issue number if needed.
     String comment = (match == null || match[2] == null) ? "" : match[2];
 
@@ skipping 18 matching lines @@
           new ExpressionParser(new Scanner(tokens)).parseSetExpression();
 
       // Look for issue number in comment.
       String issueString = null;
       match = IssueNumberPattern.firstMatch(comment);
       if (match != null) {
         issueString = match[1];
         if (issueString == null) issueString = match[2];
       }
       int issue = issueString != null ? int.parse(issueString) : null;
-      currentSection.testRules.add(
-          new TestRule(name, expression, issue, lineNumber));
+      currentSection.testRules
+          .add(new TestRule(name, expression, issue, lineNumber));
       return;
     }
 
     print("unmatched line: $line");
-  },
-  onDone: onDone);
+  }, onDone: onDone);
 }
 
-
 class TestRule {
   String name;
   SetExpression expression;
   int issue;
   int lineNumber;
 
-  TestRule(this.name,
-           this.expression,
-           this.issue,
-           this.lineNumber);
+  TestRule(this.name, this.expression, this.issue, this.lineNumber);
 
   bool get hasIssue => issue != null;
 
   String toString() => 'TestRule($name, $expression, $issue)';
 }
 
-
 class TestExpectations {
   // Only create one copy of each Set<Expectation>.
   // We just use .toString as a key, so we may make a few
   // sets that only differ in their toString element order.
   static Map _cachedSets = new Map();
 
   Map _map;
   bool _preprocessed = false;
   Map _regExpCache;
   Map _keyToRegExps;
@@ skipping 78 matching lines @@
         }
         regExps[i] = regExp;
       }
       _keyToRegExps[key] = regExps;
     });
 
     _regExpCache = null;
     _preprocessed = true;
   }
 }