Add a Pub test that runs against the real Dart SDK.

utils/tests/pub/test_pub.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.
 
 /**
  * Test infrastructure for testing pub. Unlike typical unit tests, most pub
  * tests are integration tests that stage some stuff on the file system, run
  * pub, and then validate the results. This library provides an API to build
  * tests like that.
  */
@@ skipping 427 matching lines @@
  */
 final String appPath = "myapp";
 
 /**
  * The path of the packages directory in the mock app used for tests. Relative
  * to the sandbox directory.
  */
 final String packagesPath = "$appPath/packages";
 
 /**
+ * The path to the build directory of the Dart repository. This is only set if
+ * [ensureBuild] has been run for this test.
+ */
+String _buildPath;
+
+/**
  * The type for callbacks that will be fired during [runPub]. Takes the sandbox
  * directory as a parameter.
  */
 typedef Future _ScheduledEvent(Directory parentDir);
 
 /**
  * The list of events that are scheduled to run as part of the test case.
  */
 List<_ScheduledEvent> _scheduled;
 
@@ skipping 44 matching lines @@
 }
 
 /// Get the path to the root "util/test/pub" directory containing the pub tests.
 String get testDirectory {
   var dir = new Path.fromNative(new Options().script);
   while (dir.filename != 'pub') dir = dir.directoryPath;
 
   return new File(dir.toNativePath()).fullPathSync();
 }
 
+/// Whether the tests are running on a build bot.
+bool get onBuildBot => Platform.environment.containsKey('BUILDBOT_BUILDERNAME');
+
 /**
  * Schedules a call to the Pub command-line utility. Runs Pub with [args] and
  * validates that its results match [output], [error], and [exitCode].
+ *
+ * If [realSdk] is true, runs Pub against the real Dart SDK. [ensureBuild] must
+ * be called before this method if [realSdk] is true.
  */
 void schedulePub({List<String> args, Pattern output, Pattern error,
-    int exitCode: 0}) {
+    int exitCode: 0, bool realSdk: false}) {
   _schedule((sandboxDir) {
     String pathInSandbox(path) => join(getFullPath(sandboxDir), path);
 
     return ensureDir(pathInSandbox(appPath)).chain((_) {
       // Find a Dart executable we can use to spawn. Use the same one that was
       // used to run this script itself.
       var dartBin = new Options().executable;
 
       // If the executable looks like a path, get its full path. That way we
       // can still find it when we spawn it with a different working directory.
       if (dartBin.contains(Platform.pathSeparator)) {
         dartBin = new File(dartBin).fullPathSync();
       }
 
       // Find the main pub entrypoint.
       var pubPath = fs.joinPaths(testDirectory, '../../pub/pub.dart');
 
       var dartArgs =
           ['--enable-type-checks', '--enable-asserts', pubPath, '--trace'];
       dartArgs.addAll(args);
 
       var environment = new Map.from(Platform.environment);
       environment['PUB_CACHE'] = pathInSandbox(cachePath);
-      environment['DART_SDK'] = pathInSandbox(sdkPath);
+      if (realSdk) {
+        if (_buildPath == null) {
+          throw "Test error: expected a Dart build directory to exist.";
+        }
+        environment['DART_SDK'] = join(_buildPath, "dart-sdk");
+      } else {
+        environment['DART_SDK'] = pathInSandbox(sdkPath);
+      }
 
       return runProcess(dartBin, dartArgs, workingDir: pathInSandbox(appPath),
           environment: environment);
     }).transform((result) {
       var failures = [];
 
       _validateOutput(failures, 'stdout', output, result.stdout);
       _validateOutput(failures, 'stderr', error, result.stderr);
 
       if (result.exitCode != exitCode) {
@@ skipping 30 matching lines @@
  * Skips the current test if Git is not installed. This validates that the
  * current test is running on a buildbot in which case we expect git to be
  * installed. If we are not running on the buildbot, we will instead see if git
  * is installed and skip the test if not. This way, users don't need to have git
  * installed to run the tests locally (unless they actually care about the pub
  * git tests).
  */
 void ensureGit() {
   _schedule((_) {
     return isGitInstalled.transform((installed) {
-      if (!installed &&
-          !Platform.environment.containsKey('BUILDBOT_BUILDERNAME')) {
+      if (!installed && !onBuildBot) {
         _abortScheduled = true;
       }
       return null;
     });
   });
 }
 
+/// Skips the current test if the Dart repository's build step has not been run.
+/// If we're running on a build bot, this will not skip the test.
+///
+/// This ensures that users don't need to have built Dart themselves to run the
+/// test, but that the test will always run on the build bot.
+void ensureBuild() {
+  _schedule((_) {
+    return _findBuildDirectory().transform((dir) {
+      if (dir == null && !onBuildBot) {
+        _abortScheduled = true;
+      }
+    });
+  });
+}
+
+/// All possible names for the output directory of the Dart build.
+final List<String> _buildNames = [
+  'ReleaseIA32', 'DebugIA32', 'ReleaseX64', 'DebugX64', 'ReleaseSIMARM',
+  'DebugSIMARM', 'ReleaseARM', 'DebugARM'
+];
+
+/// All possible names for the parent directory of the Dart build.
+final Map<String, String> _buildParentNames = {
+  'mac': 'xcodebuild', 'linux': 'out', 'windows': 'build'
+};
+
+/// Returns the path to the output directory of the Dart build, or null if none
+/// is found. This also sets [_buildPath] if a build directory is found.
+Future<String> _findBuildDirectory() {
+  if (_buildPath != null) return new Future.immediate(_buildPath);
+
+  var buildDirectories = flatten(_buildNames.map((name) {
+    var parent = _buildParentNames[Platform.operatingSystem];
+    return join(testDirectory, '../../..', parent, name);
+  }));
+
+  return Futures.wait(buildDirectories.map(dirExists)).transform((found) {
+    for (var i = 0; i < found.length; i++) {
+      if (found[i]) {
+        _buildPath = buildDirectories[i];
+        return _buildPath;
+      }
+    }
+    return null;
+  });
+}
+
 Future<Directory> _setUpSandbox() {
   return createTempDir();
 }
 
 Future _runScheduled(Directory parentDir, List<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
   var iterator = scheduled.iterator();
 
   Future runNextEvent(_) {
     if (_abortScheduled || !iterator.hasNext()) {
@@ skipping 591 matching lines @@
 }
 
 /**
  * Schedules a callback to be called after Pub is run with [runPub], even if it
  * fails.
  */
 void _scheduleCleanup(_ScheduledEvent event) {
   if (_scheduledCleanup == null) _scheduledCleanup = [];
   _scheduledCleanup.add(event);
 }