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

sdk/lib/_internal/pub_generated/test/validator/dependency_test.dart

 // Copyright (c) 2013, 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.
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart';
 import 'package:path/path.dart' as path;
 import 'package:scheduled_test/scheduled_test.dart';
 
 import '../../lib/src/entrypoint.dart';
 import '../../lib/src/validator.dart';
 import '../../lib/src/validator/dependency.dart';
 import '../descriptor.dart' as d;
 import '../test_pub.dart';
 import 'utils.dart';
 
 Validator dependency(Entrypoint entrypoint) =>
-  new DependencyValidator(entrypoint);
+    new DependencyValidator(entrypoint);
 
 expectDependencyValidationError(String error) {
-  expect(schedulePackageValidation(dependency),
+  expect(
+      schedulePackageValidation(dependency),
       completion(pairOf(anyElement(contains(error)), isEmpty)));
 }
 
 expectDependencyValidationWarning(String warning) {
-  expect(schedulePackageValidation(dependency),
+  expect(
+      schedulePackageValidation(dependency),
       completion(pairOf(isEmpty, anyElement(contains(warning)))));
 }
 
 /// Sets up a test package with dependency [dep] and mocks a server with
 /// [hostedVersions] of the package available.
 setUpDependency(Map dep, {List<String> hostedVersions}) {
   useMockClient(new MockClient((request) {
     expect(request.method, equals("GET"));
     expect(request.url.path, equals("/api/packages/foo"));
 
     if (hostedVersions == null) {
       return new Future.value(new http.Response("not found", 404));
     } else {
       return new Future.value(new http.Response(JSON.encode({
         "name": "foo",
         "uploaders": ["nweiz@google.com"],
-        "versions": hostedVersions.map((version) =>
-            packageVersionApiMap(packageMap('foo', version))).toList()
+        "versions": hostedVersions.map(
+            (version) => packageVersionApiMap(packageMap('foo', version))).toList()
       }), 200));
     }
   }));
 
-  d.dir(appPath, [
-    d.libPubspec("test_pkg", "1.0.0", deps: {"foo": dep})
-  ]).create();
+  d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
+      "foo": dep
+    })]).create();
 }
 
 main() {
   initConfig();
 
   group('should consider a package valid if it', () {
     integration('looks normal', () {
       d.validPackage.create();
       expectNoValidationError(dependency);
     });
 
     integration('has a ^ constraint with an appropriate SDK constraint', () {
-      d.dir(appPath, [
-        d.libPubspec("test_pkg", "1.0.0", deps: {
+      d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
           "foo": "^1.2.3"
-        }, sdk: ">=1.8.0 <2.0.0")
-      ]).create();
+        }, sdk: ">=1.8.0 <2.0.0")]).create();
       expectNoValidationError(dependency);
     });
   });
 
   group('should consider a package invalid if it', () {
     setUp(d.validPackage.create);
 
     group('has a git dependency', () {
       group('where a hosted version exists', () {
         integration("and should suggest the hosted primary version", () {
-          setUpDependency({'git': 'git://github.com/dart-lang/foo'},
-              hostedVersions: ["3.0.0-pre", "2.0.0", "1.0.0"]);
+          setUpDependency({
+            'git': 'git://github.com/dart-lang/foo'
+          }, hostedVersions: ["3.0.0-pre", "2.0.0", "1.0.0"]);
           expectDependencyValidationWarning('  foo: ">=2.0.0 <3.0.0"');
         });
 
-        integration("and should suggest the hosted prerelease version if "
-                    "it's the only version available", () {
-          setUpDependency({'git': 'git://github.com/dart-lang/foo'},
-              hostedVersions: ["3.0.0-pre", "2.0.0-pre"]);
+        integration(
+            "and should suggest the hosted prerelease version if "
+                "it's the only version available",
+            () {
+          setUpDependency({
+            'git': 'git://github.com/dart-lang/foo'
+          }, hostedVersions: ["3.0.0-pre", "2.0.0-pre"]);
           expectDependencyValidationWarning('  foo: ">=3.0.0-pre <4.0.0"');
         });
 
-        integration("and should suggest a tighter constraint if primary is "
-                    "pre-1.0.0", () {
-          setUpDependency({'git': 'git://github.com/dart-lang/foo'},
-              hostedVersions: ["0.0.1", "0.0.2"]);
+        integration(
+            "and should suggest a tighter constraint if primary is " "pre-1.0.0",
+            () {
+          setUpDependency({
+            'git': 'git://github.com/dart-lang/foo'
+          }, hostedVersions: ["0.0.1", "0.0.2"]);
           expectDependencyValidationWarning('  foo: ">=0.0.2 <0.1.0"');
         });
       });
 
       group('where no hosted version exists', () {
         integration("and should use the other source's version", () {
           setUpDependency({
             'git': 'git://github.com/dart-lang/foo',
             'version': '>=1.0.0 <2.0.0'
           });
           expectDependencyValidationWarning('  foo: ">=1.0.0 <2.0.0"');
         });
 
-        integration("and should use the other source's unquoted version if "
-                    "concrete", () {
+        integration(
+            "and should use the other source's unquoted version if " "concrete",
+            () {
           setUpDependency({
             'git': 'git://github.com/dart-lang/foo',
             'version': '0.2.3'
           });
           expectDependencyValidationWarning('  foo: 0.2.3');
         });
       });
     });
 
     group('has a path dependency', () {
       group('where a hosted version exists', () {
         integration("and should suggest the hosted primary version", () {
-          setUpDependency({'path': path.join(sandboxDir, 'foo')},
-              hostedVersions: ["3.0.0-pre", "2.0.0", "1.0.0"]);
+          setUpDependency({
+            'path': path.join(sandboxDir, 'foo')
+          }, hostedVersions: ["3.0.0-pre", "2.0.0", "1.0.0"]);
           expectDependencyValidationError('  foo: ">=2.0.0 <3.0.0"');
         });
 
-        integration("and should suggest the hosted prerelease version if "
-                    "it's the only version available", () {
-          setUpDependency({'path': path.join(sandboxDir, 'foo')},
-              hostedVersions: ["3.0.0-pre", "2.0.0-pre"]);
+        integration(
+            "and should suggest the hosted prerelease version if "
+                "it's the only version available",
+            () {
+          setUpDependency({
+            'path': path.join(sandboxDir, 'foo')
+          }, hostedVersions: ["3.0.0-pre", "2.0.0-pre"]);
           expectDependencyValidationError('  foo: ">=3.0.0-pre <4.0.0"');
         });
 
-        integration("and should suggest a tighter constraint if primary is "
-                    "pre-1.0.0", () {
-          setUpDependency({'path': path.join(sandboxDir, 'foo')},
-              hostedVersions: ["0.0.1", "0.0.2"]);
+        integration(
+            "and should suggest a tighter constraint if primary is " "pre-1.0.0",
+            () {
+          setUpDependency({
+            'path': path.join(sandboxDir, 'foo')
+          }, hostedVersions: ["0.0.1", "0.0.2"]);
           expectDependencyValidationError('  foo: ">=0.0.2 <0.1.0"');
         });
       });
 
       group('where no hosted version exists', () {
         integration("and should use the other source's version", () {
           setUpDependency({
             'path': path.join(sandboxDir, 'foo'),
             'version': '>=1.0.0 <2.0.0'
           });
           expectDependencyValidationError('  foo: ">=1.0.0 <2.0.0"');
         });
 
-        integration("and should use the other source's unquoted version if "
-                    "concrete", () {
+        integration(
+            "and should use the other source's unquoted version if " "concrete",
+            () {
           setUpDependency({
             'path': path.join(sandboxDir, 'foo'),
             'version': '0.2.3'
           });
           expectDependencyValidationError('  foo: 0.2.3');
         });
       });
     });
 
     group('has an unconstrained dependency', () {
       group('and it should not suggest a version', () {
         integration("if there's no lockfile", () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "any"
-            })
-          ]).create();
+            })]).create();
 
-          expect(schedulePackageValidation(dependency), completion(
-              pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
+          expect(
+              schedulePackageValidation(dependency),
+              completion(pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
         });
 
-        integration("if the lockfile doesn't have an entry for the "
-            "dependency", () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+        integration(
+            "if the lockfile doesn't have an entry for the " "dependency",
+            () {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "any"
-            }),
-            d.file("pubspec.lock", JSON.encode({
+            }), d.file("pubspec.lock", JSON.encode({
               'packages': {
                 'bar': {
                   'version': '1.2.3',
                   'source': 'hosted',
                   'description': {
                     'name': 'bar',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
-            }))
-          ]).create();
+            }))]).create();
 
-          expect(schedulePackageValidation(dependency), completion(
-              pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
+          expect(
+              schedulePackageValidation(dependency),
+              completion(pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
         });
       });
 
       group('with a lockfile', () {
-        integration('and it should suggest a constraint based on the locked '
-            'version', () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+        integration(
+            'and it should suggest a constraint based on the locked ' 'version',
+            () {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "any"
-            }),
-            d.file("pubspec.lock", JSON.encode({
+            }), d.file("pubspec.lock", JSON.encode({
               'packages': {
                 'foo': {
                   'version': '1.2.3',
                   'source': 'hosted',
                   'description': {
                     'name': 'foo',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
-            }))
-          ]).create();
+            }))]).create();
 
           expectDependencyValidationWarning('  foo: ">=1.2.3 <2.0.0"');
         });
 
-        integration('and it should suggest a concrete constraint if the locked '
-            'version is pre-1.0.0', () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+        integration(
+            'and it should suggest a concrete constraint if the locked '
+                'version is pre-1.0.0',
+            () {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "any"
-            }),
-            d.file("pubspec.lock", JSON.encode({
+            }), d.file("pubspec.lock", JSON.encode({
               'packages': {
                 'foo': {
                   'version': '0.1.2',
                   'source': 'hosted',
                   'description': {
                     'name': 'foo',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
-            }))
-          ]).create();
+            }))]).create();
 
           expectDependencyValidationWarning('  foo: ">=0.1.2 <0.2.0"');
         });
       });
     });
 
-    integration('with a single-version dependency and it should suggest a '
-        'constraint based on the version', () {
-      d.dir(appPath, [
-        d.libPubspec("test_pkg", "1.0.0", deps: {
+    integration(
+        'with a single-version dependency and it should suggest a '
+            'constraint based on the version',
+        () {
+      d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
           "foo": "1.2.3"
-        })
-      ]).create();
+        })]).create();
 
       expectDependencyValidationWarning('  foo: ">=1.2.3 <2.0.0"');
     });
 
     group('has a dependency without a lower bound', () {
       group('and it should not suggest a version', () {
         integration("if there's no lockfile", () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "<3.0.0"
-            })
-          ]).create();
+            })]).create();
 
-          expect(schedulePackageValidation(dependency), completion(
-              pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
+          expect(
+              schedulePackageValidation(dependency),
+              completion(pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
         });
 
-        integration("if the lockfile doesn't have an entry for the "
-            "dependency", () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+        integration(
+            "if the lockfile doesn't have an entry for the " "dependency",
+            () {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "<3.0.0"
-            }),
-            d.file("pubspec.lock", JSON.encode({
+            }), d.file("pubspec.lock", JSON.encode({
               'packages': {
                 'bar': {
                   'version': '1.2.3',
                   'source': 'hosted',
                   'description': {
                     'name': 'bar',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
-            }))
-          ]).create();
+            }))]).create();
 
-          expect(schedulePackageValidation(dependency), completion(
-              pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
+          expect(
+              schedulePackageValidation(dependency),
+              completion(pairOf(isEmpty, everyElement(isNot(contains("\n  foo:"))))));
         });
       });
 
       group('with a lockfile', () {
-        integration('and it should suggest a constraint based on the locked '
-            'version', () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+        integration(
+            'and it should suggest a constraint based on the locked ' 'version',
+            () {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "<3.0.0"
-            }),
-            d.file("pubspec.lock", JSON.encode({
+            }), d.file("pubspec.lock", JSON.encode({
               'packages': {
                 'foo': {
                   'version': '1.2.3',
                   'source': 'hosted',
                   'description': {
                     'name': 'foo',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
-            }))
-          ]).create();
+            }))]).create();
 
           expectDependencyValidationWarning('  foo: ">=1.2.3 <3.0.0"');
         });
 
         integration('and it should preserve the upper-bound operator', () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "<=3.0.0"
-            }),
-            d.file("pubspec.lock", JSON.encode({
+            }), d.file("pubspec.lock", JSON.encode({
               'packages': {
                 'foo': {
                   'version': '1.2.3',
                   'source': 'hosted',
                   'description': {
                     'name': 'foo',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
-            }))
-          ]).create();
+            }))]).create();
 
           expectDependencyValidationWarning('  foo: ">=1.2.3 <=3.0.0"');
         });
 
-        integration('and it should expand the suggested constraint if the '
-            'locked version matches the upper bound', () {
-          d.dir(appPath, [
-            d.libPubspec("test_pkg", "1.0.0", deps: {
+        integration(
+            'and it should expand the suggested constraint if the '
+                'locked version matches the upper bound',
+            () {
+          d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
               "foo": "<=1.2.3"
-            }),
-            d.file("pubspec.lock", JSON.encode({
+            }), d.file("pubspec.lock", JSON.encode({
               'packages': {
                 'foo': {
                   'version': '1.2.3',
                   'source': 'hosted',
                   'description': {
                     'name': 'foo',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
-            }))
-          ]).create();
+            }))]).create();
 
           expectDependencyValidationWarning('  foo: ">=1.2.3 <2.0.0"');
         });
       });
     });
 
     group('with a dependency without an upper bound', () {
-      integration('and it should suggest a constraint based on the lower bound',
+      integration(
+          'and it should suggest a constraint based on the lower bound',
           () {
-        d.dir(appPath, [
-          d.libPubspec("test_pkg", "1.0.0", deps: {
+        d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
             "foo": ">=1.2.3"
-          })
-        ]).create();
+          })]).create();
 
         expectDependencyValidationWarning('  foo: ">=1.2.3 <2.0.0"');
       });
 
       integration('and it should preserve the lower-bound operator', () {
-        d.dir(appPath, [
-          d.libPubspec("test_pkg", "1.0.0", deps: {
+        d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
             "foo": ">1.2.3"
-          })
-        ]).create();
+          })]).create();
 
         expectDependencyValidationWarning('  foo: ">1.2.3 <2.0.0"');
       });
     });
 
     group('has a ^ dependency', () {
       integration("without an SDK constraint", () {
-        d.dir(appPath, [
-          d.libPubspec("integration_pkg", "1.0.0", deps: {
+        d.dir(appPath, [d.libPubspec("integration_pkg", "1.0.0", deps: {
             "foo": "^1.2.3"
-          })
-        ]).create();
+          })]).create();
 
         expectDependencyValidationError('  foo: ">=1.2.3 <2.0.0"');
       });
 
       integration("with a too-broad SDK constraint", () {
-        d.dir(appPath, [
-          d.libPubspec("test_pkg", "1.0.0", deps: {
+        d.dir(appPath, [d.libPubspec("test_pkg", "1.0.0", deps: {
             "foo": "^1.2.3"
-          }, sdk: ">=1.5.0 <2.0.0")
-        ]).create();
+          }, sdk: ">=1.5.0 <2.0.0")]).create();
 
         expectDependencyValidationError('  foo: ">=1.2.3 <2.0.0"');
       });
     });
   });
 }