Revert "Revert "Use native async/await support in pub.""

sdk/lib/_internal/pub_generated/test/pubspec_test.dart

Index: sdk/lib/_internal/pub_generated/test/pubspec_test.dart
diff --git a/sdk/lib/_internal/pub_generated/test/pubspec_test.dart b/sdk/lib/_internal/pub_generated/test/pubspec_test.dart
deleted file mode 100644
index 1418bf9bbfede1d9d5d46b7a5395d1efbcdc3584..0000000000000000000000000000000000000000
--- a/sdk/lib/_internal/pub_generated/test/pubspec_test.dart
+++ /dev/null
@@ -1,558 +0,0 @@
-// 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 pubspec_test;
-
-import 'dart:async';
-
-import 'package:pub_semver/pub_semver.dart';
-import 'package:unittest/unittest.dart';
-
-import '../lib/src/package.dart';
-import '../lib/src/pubspec.dart';
-import '../lib/src/source.dart';
-import '../lib/src/source/path.dart';
-import '../lib/src/source_registry.dart';
-import 'test_pub.dart';
-
-class MockSource extends Source {
-  final String name = "mock";
-
-  Future<Pubspec> doDescribe(PackageId id) =>
-      throw new UnsupportedError("Cannot describe mock packages.");
-
-  Future get(PackageId id, String symlink) =>
-      throw new UnsupportedError("Cannot get a mock package.");
-
-  Future<String> getDirectory(PackageId id) =>
-      throw new UnsupportedError("Cannot get the directory for mock packages.");
-
-  dynamic parseDescription(String filePath, description, {bool fromLockFile:
-      false}) {
-    if (description != 'ok') throw new FormatException('Bad');
-    return description;
-  }
-
-  bool descriptionsEqual(description1, description2) =>
-      description1 == description2;
-
-  String packageName(description) => 'foo';
-}
-
-main() {
-  initConfig();
-  group('parse()', () {
-    var sources = new SourceRegistry();
-    sources.register(new MockSource());
-    sources.register(new PathSource());
-
-    var throwsPubspecException =
-        throwsA(new isInstanceOf<PubspecException>('PubspecException'));
-
-    expectPubspecException(String contents, fn(Pubspec pubspec),
-        [String expectedContains]) {
-      var expectation = throwsPubspecException;
-      if (expectedContains != null) {
-        expectation = throwsA(
-            allOf(
-                new isInstanceOf<PubspecException>('PubspecException'),
-                predicate((error) => error.message.contains(expectedContains))));
-      }
-
-      var pubspec = new Pubspec.parse(contents, sources);
-      expect(() => fn(pubspec), expectation);
-    }
-
-    test("doesn't eagerly throw an error for an invalid field", () {
-      // Shouldn't throw an error.
-      new Pubspec.parse('version: not a semver', sources);
-    });
-
-    test(
-        "eagerly throws an error if the pubspec name doesn't match the "
-            "expected name",
-        () {
-      expect(
-          () => new Pubspec.parse("name: foo", sources, expectedName: 'bar'),
-          throwsPubspecException);
-    });
-
-    test(
-        "eagerly throws an error if the pubspec doesn't have a name and an "
-            "expected name is passed",
-        () {
-      expect(
-          () => new Pubspec.parse("{}", sources, expectedName: 'bar'),
-          throwsPubspecException);
-    });
-
-    test("allows a version constraint for dependencies", () {
-      var pubspec = new Pubspec.parse('''
-dependencies:
-  foo:
-    mock: ok
-    version: ">=1.2.3 <3.4.5"
-''', sources);
-
-      var foo = pubspec.dependencies[0];
-      expect(foo.name, equals('foo'));
-      expect(foo.constraint.allows(new Version(1, 2, 3)), isTrue);
-      expect(foo.constraint.allows(new Version(1, 2, 5)), isTrue);
-      expect(foo.constraint.allows(new Version(3, 4, 5)), isFalse);
-    });
-
-    test("allows an empty dependencies map", () {
-      var pubspec = new Pubspec.parse('''
-dependencies:
-''', sources);
-
-      expect(pubspec.dependencies, isEmpty);
-    });
-
-    test("allows a version constraint for dev dependencies", () {
-      var pubspec = new Pubspec.parse('''
-dev_dependencies:
-  foo:
-    mock: ok
-    version: ">=1.2.3 <3.4.5"
-''', sources);
-
-      var foo = pubspec.devDependencies[0];
-      expect(foo.name, equals('foo'));
-      expect(foo.constraint.allows(new Version(1, 2, 3)), isTrue);
-      expect(foo.constraint.allows(new Version(1, 2, 5)), isTrue);
-      expect(foo.constraint.allows(new Version(3, 4, 5)), isFalse);
-    });
-
-    test("allows an empty dev dependencies map", () {
-      var pubspec = new Pubspec.parse('''
-dev_dependencies:
-''', sources);
-
-      expect(pubspec.devDependencies, isEmpty);
-    });
-
-    test("allows a version constraint for dependency overrides", () {
-      var pubspec = new Pubspec.parse('''
-dependency_overrides:
-  foo:
-    mock: ok
-    version: ">=1.2.3 <3.4.5"
-''', sources);
-
-      var foo = pubspec.dependencyOverrides[0];
-      expect(foo.name, equals('foo'));
-      expect(foo.constraint.allows(new Version(1, 2, 3)), isTrue);
-      expect(foo.constraint.allows(new Version(1, 2, 5)), isTrue);
-      expect(foo.constraint.allows(new Version(3, 4, 5)), isFalse);
-    });
-
-    test("allows an empty dependency overrides map", () {
-      var pubspec = new Pubspec.parse('''
-dependency_overrides:
-''', sources);
-
-      expect(pubspec.dependencyOverrides, isEmpty);
-    });
-
-    test("allows an unknown source", () {
-      var pubspec = new Pubspec.parse('''
-dependencies:
-  foo:
-    unknown: blah
-''', sources);
-
-      var foo = pubspec.dependencies[0];
-      expect(foo.name, equals('foo'));
-      expect(foo.source, equals('unknown'));
-    });
-
-    test("throws if a package is in dependencies and dev_dependencies", () {
-      expectPubspecException('''
-dependencies:
-  foo:
-    mock: ok
-dev_dependencies:
-  foo:
-    mock: ok
-''', (pubspec) {
-        // This check only triggers if both [dependencies] and [devDependencies]
-        // are accessed.
-        pubspec.dependencies;
-        pubspec.devDependencies;
-      });
-    });
-
-    test("throws if it dependes on itself", () {
-      expectPubspecException('''
-name: myapp
-dependencies:
-  myapp:
-    mock: ok
-''', (pubspec) => pubspec.dependencies);
-    });
-
-    test("throws if it has a dev dependency on itself", () {
-      expectPubspecException('''
-name: myapp
-dev_dependencies:
-  myapp:
-    mock: ok
-''', (pubspec) => pubspec.devDependencies);
-    });
-
-    test("throws if it has an override on itself", () {
-      expectPubspecException('''
-name: myapp
-dependency_overrides:
-  myapp:
-    mock: ok
-''', (pubspec) => pubspec.dependencyOverrides);
-    });
-
-    test("throws if the description isn't valid", () {
-      expectPubspecException('''
-dependencies:
-  foo:
-    mock: bad
-''', (pubspec) => pubspec.dependencies);
-    });
-
-    test("throws if dependency version is not a string", () {
-      expectPubspecException('''
-dependencies:
-  foo:
-    mock: ok
-    version: 1.2
-''', (pubspec) => pubspec.dependencies);
-    });
-
-    test("throws if version is not a version constraint", () {
-      expectPubspecException('''
-dependencies:
-  foo:
-    mock: ok
-    version: not constraint
-''', (pubspec) => pubspec.dependencies);
-    });
-
-    test("throws if 'name' is not a string", () {
-      expectPubspecException(
-          'name: [not, a, string]',
-          (pubspec) => pubspec.name);
-    });
-
-    test("throws if version is not a string", () {
-      expectPubspecException(
-          'version: [2, 0, 0]',
-          (pubspec) => pubspec.version,
-          '"version" field must be a string');
-    });
-
-    test("throws if version is malformed (looking like a double)", () {
-      expectPubspecException(
-          'version: 2.1',
-          (pubspec) => pubspec.version,
-          '"version" field must have three numeric components: major, minor, '
-              'and patch. Instead of "2.1", consider "2.1.0"');
-    });
-
-    test("throws if version is malformed (looking like an int)", () {
-      expectPubspecException(
-          'version: 2',
-          (pubspec) => pubspec.version,
-          '"version" field must have three numeric components: major, minor, '
-              'and patch. Instead of "2", consider "2.0.0"');
-    });
-
-    test("throws if version is not a version", () {
-      expectPubspecException(
-          'version: not version',
-          (pubspec) => pubspec.version);
-    });
-
-    test("throws if transformers isn't a list", () {
-      expectPubspecException(
-          'transformers: "not list"',
-          (pubspec) => pubspec.transformers,
-          '"transformers" field must be a list');
-    });
-
-    test("throws if a transformer isn't a string or map", () {
-      expectPubspecException(
-          'transformers: [12]',
-          (pubspec) => pubspec.transformers,
-          'A transformer must be a string or map.');
-    });
-
-    test("throws if a transformer's configuration isn't a map", () {
-      expectPubspecException(
-          'transformers: [{pkg: 12}]',
-          (pubspec) => pubspec.transformers,
-          "A transformer's configuration must be a map.");
-    });
-
-    test(
-        "throws if a transformer's configuration contains an unknown "
-            "reserved key at the top level",
-        () {
-      expectPubspecException('''
-name: pkg
-transformers: [{pkg: {\$key: "value"}}]''',
-          (pubspec) => pubspec.transformers,
-          'Invalid transformer config: Unknown reserved field.');
-    });
-
-    test(
-        "doesn't throw if a transformer's configuration contains a "
-            "non-top-level key beginning with a dollar sign",
-        () {
-      var pubspec = new Pubspec.parse('''
-name: pkg
-transformers:
-- pkg: {outer: {\$inner: value}}
-''', sources);
-
-      var pkg = pubspec.transformers[0].single;
-      expect(pkg.configuration["outer"]["\$inner"], equals("value"));
-    });
-
-    test("throws if the \$include value is not a string or list", () {
-      expectPubspecException('''
-name: pkg
-transformers:
-- pkg: {\$include: 123}''',
-          (pubspec) => pubspec.transformers,
-          'Invalid transformer config: "\$include" field must be a string or ' 'list.');
-    });
-
-    test("throws if the \$include list contains a non-string", () {
-      expectPubspecException('''
-name: pkg
-transformers:
-- pkg: {\$include: ["ok", 123, "alright", null]}''',
-          (pubspec) => pubspec.transformers,
-          'Invalid transformer config: "\$include" field may contain only ' 'strings.');
-    });
-
-    test("throws if the \$exclude value is not a string or list", () {
-      expectPubspecException('''
-name: pkg
-transformers:
-- pkg: {\$exclude: 123}''',
-          (pubspec) => pubspec.transformers,
-          'Invalid transformer config: "\$exclude" field must be a string or ' 'list.');
-    });
-
-    test("throws if the \$exclude list contains a non-string", () {
-      expectPubspecException('''
-name: pkg
-transformers:
-- pkg: {\$exclude: ["ok", 123, "alright", null]}''',
-          (pubspec) => pubspec.transformers,
-          'Invalid transformer config: "\$exclude" field may contain only ' 'strings.');
-    });
-
-    test("throws if a transformer is not from a dependency", () {
-      expectPubspecException('''
-name: pkg
-transformers: [foo]
-''', (pubspec) => pubspec.transformers, '"foo" is not a dependency.');
-    });
-
-    test("allows a transformer from a normal dependency", () {
-      var pubspec = new Pubspec.parse('''
-name: pkg
-dependencies:
-  foo:
-    mock: ok
-transformers:
-- foo''', sources);
-
-      expect(pubspec.transformers[0].single.id.package, equals("foo"));
-    });
-
-    test("allows a transformer from a dev dependency", () {
-      var pubspec = new Pubspec.parse('''
-name: pkg
-dev_dependencies:
-  foo:
-    mock: ok
-transformers:
-- foo''', sources);
-
-      expect(pubspec.transformers[0].single.id.package, equals("foo"));
-    });
-
-    test("allows a transformer from a dependency override", () {
-      var pubspec = new Pubspec.parse('''
-name: pkg
-dependency_overrides:
-  foo:
-    mock: ok
-transformers:
-- foo''', sources);
-
-      expect(pubspec.transformers[0].single.id.package, equals("foo"));
-    });
-
-    test("allows comment-only files", () {
-      var pubspec = new Pubspec.parse('''
-# No external dependencies yet
-# Including for completeness
-# ...and hoping the spec expands to include details about author, version, etc
-# See http://www.dartlang.org/docs/pub-package-manager/ for details
-''', sources);
-      expect(pubspec.version, equals(Version.none));
-      expect(pubspec.dependencies, isEmpty);
-    });
-
-    test("throws a useful error for unresolvable path dependencies", () {
-      expectPubspecException('''
-name: pkg
-dependencies:
-  from_path: {path: non_local_path}
-''',
-          (pubspec) => pubspec.dependencies,
-          '"non_local_path" is a relative path, but this isn\'t a local ' 'pubspec.');
-    });
-
-    group("environment", () {
-      test("defaults to any SDK constraint if environment is omitted", () {
-        var pubspec = new Pubspec.parse('', sources);
-        expect(pubspec.environment.sdkVersion, equals(VersionConstraint.any));
-      });
-
-      test("allows an empty environment map", () {
-        var pubspec = new Pubspec.parse('''
-environment:
-''', sources);
-        expect(pubspec.environment.sdkVersion, equals(VersionConstraint.any));
-      });
-
-      test("throws if the environment value isn't a map", () {
-        expectPubspecException(
-            'environment: []',
-            (pubspec) => pubspec.environment);
-      });
-
-      test("allows a version constraint for the sdk", () {
-        var pubspec = new Pubspec.parse('''
-environment:
-  sdk: ">=1.2.3 <2.3.4"
-''', sources);
-        expect(
-            pubspec.environment.sdkVersion,
-            equals(new VersionConstraint.parse(">=1.2.3 <2.3.4")));
-      });
-
-      test("throws if the sdk isn't a string", () {
-        expectPubspecException(
-            'environment: {sdk: []}',
-            (pubspec) => pubspec.environment);
-        expectPubspecException(
-            'environment: {sdk: 1.0}',
-            (pubspec) => pubspec.environment);
-      });
-
-      test("throws if the sdk isn't a valid version constraint", () {
-        expectPubspecException(
-            'environment: {sdk: "oopies"}',
-            (pubspec) => pubspec.environment);
-      });
-    });
-
-    group("publishTo", () {
-      test("defaults to null if omitted", () {
-        var pubspec = new Pubspec.parse('', sources);
-        expect(pubspec.publishTo, isNull);
-      });
-
-      test("throws if not a string", () {
-        expectPubspecException(
-            'publish_to: 123',
-            (pubspec) => pubspec.publishTo);
-      });
-
-      test("allows a URL", () {
-        var pubspec = new Pubspec.parse('''
-publish_to: http://example.com
-''', sources);
-        expect(pubspec.publishTo, equals("http://example.com"));
-      });
-
-      test("allows none", () {
-        var pubspec = new Pubspec.parse('''
-publish_to: none
-''', sources);
-        expect(pubspec.publishTo, equals("none"));
-      });
-
-      test("throws on other strings", () {
-        expectPubspecException(
-            'publish_to: http://bad.url:not-port',
-            (pubspec) => pubspec.publishTo);
-      });
-    });
-
-    group("executables", () {
-      test("defaults to an empty map if omitted", () {
-        var pubspec = new Pubspec.parse('', sources);
-        expect(pubspec.executables, isEmpty);
-      });
-
-      test("allows simple names for keys and most characters in values", () {
-        var pubspec = new Pubspec.parse('''
-executables:
-  abcDEF-123_: "abc DEF-123._"
-''', sources);
-        expect(pubspec.executables['abcDEF-123_'], equals('abc DEF-123._'));
-      });
-
-      test("throws if not a map", () {
-        expectPubspecException(
-            'executables: not map',
-            (pubspec) => pubspec.executables);
-      });
-
-      test("throws if key is not a string", () {
-        expectPubspecException(
-            'executables: {123: value}',
-            (pubspec) => pubspec.executables);
-      });
-
-      test("throws if a key isn't a simple name", () {
-        expectPubspecException(
-            'executables: {funny/name: ok}',
-            (pubspec) => pubspec.executables);
-      });
-
-      test("throws if a value is not a string", () {
-        expectPubspecException(
-            'executables: {command: 123}',
-            (pubspec) => pubspec.executables);
-      });
-
-      test("throws if a value contains a path separator", () {
-        expectPubspecException(
-            'executables: {command: funny_name/part}',
-            (pubspec) => pubspec.executables);
-      });
-
-      test("throws if a value contains a windows path separator", () {
-        expectPubspecException(
-            r'executables: {command: funny_name\part}',
-            (pubspec) => pubspec.executables);
-      });
-
-      test("uses the key if the value is null", () {
-        var pubspec = new Pubspec.parse('''
-executables:
-  command:
-''', sources);
-        expect(pubspec.executables['command'], equals('command'));
-      });
-    });
-  });
-}