Fix a couple of minor issues and try to resolve #2740.

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 57 matching lines @@
       Expect.equals(result.stderr.length, 0,
           'Did not expect any output on stderr, and got:\n' +
           Strings.join(result.stderr, '\n'));
 
       Expect.equals(result.exitCode, exitCode,
           'Pub returned exit code ${result.exitCode}, expected $exitCode.');
 
       return _validateExpectedPackages(createdAppDir, expectedPackageDir);
     });
 
-    future.then((valid) {
-      Expect.isTrue(valid); // TODO(bob): Report which expectation failed.
+    future.then((error) {
+      // Null means there were no errors.
+      if (error != null) Expect.fail(error);
+
       deleteSandboxIfCreated();
     });
 
     future.handleException((error) {
       deleteSandboxIfCreated();
     });
   });
 }
 
 Future<Directory> _setUpSandbox() {
-  return cleanDir('pub-test-sandbox');
+  return createTempDir('pub-test-sandbox-');

[nweiz, 2012/04/26 23:42:47]

Why?

 }
 
 Future _setUpCache(Directory sandboxDir, List<Descriptor> cache) {
   // No cache.
   if (cache == null) return new Future.immediate(null);
 
   return dir('pub-cache', cache).create(sandboxDir);
 }
 
 Future _setUpApp(Directory sandboxDir, Descriptor app) {
@@ skipping 12 matching lines @@
 
   // Find the main pub entrypoint.
   final pubPath = fs.joinPaths(scriptDir, '../../pub/pub.dart');
 
   final args = [pubPath];
   args.addAll(pubArgs);
 
   return runProcess(dartBin, args, workingDir);
 }
 
-Future<bool> _validateExpectedPackages(Directory appDir,
+/**
+ * Validates the contents of the "packages" directory inside [appDir] against
+ * [expectedPackageDir].
+ */
+Future<String> _validateExpectedPackages(Directory appDir,
     List<Descriptor> expectedPackageDir) {
   // No expectation.
-  if (expectedPackageDir == null) return new Future.immediate(true);
+  if (expectedPackageDir == null) return new Future.immediate(null);
 
   return dir('packages', expectedPackageDir).validate(appDir.path);
 }
 
 /**
  * Compares the [actual] output from running pub with [expectedText]. Ignores
  * leading and trailing whitespace differences and tries to report the
  * offending difference in a nice way.
  */
 void _validateOutput(String expectedText, List<String> actual) {
@@ skipping 49 matching lines @@
   Descriptor(this.name);
 
   /**
    * Creates the file or directory within [dir]. Returns a [Future] that is
    * completed after the creation is done.
    */
   abstract Future create(String dir);
 
   /**
    * Validates that this descriptor correctly matches the corresponding file
-   * system entry within [dir]. Returns a [Future] that completes when the
-   * validation is done.
+   * system entry within [dir]. Returns a [Future] that completes to `null` if
+   * the entry is valid, or a message describing the error if it failed.
    */
-  abstract Future<bool> validate(String dir);
+  abstract Future<String> validate(String dir);
 }
 
 /**
  * Describes a file. These are used both for setting up an expected directory
  * tree before running a test, and for validating that the file system matches
  * some expectations after running it.
  */
 class FileDescriptor extends Descriptor {
   /**
    * The text contents of the file.
    */
   final String contents;
 
   FileDescriptor(String name, this.contents) : super(name);
 
   /**
    * Creates the file within [dir]. Returns a [Future] that is completed after
    * the creation is done.
    */
   Future<File> create(String dir) {
     return writeTextFile(join(dir, name), contents);
   }
 
   /**
    * Validates that this file correctly matches the actual file at [path].
    */
-  Future<bool> validate(String path) {
+  Future<String> validate(String path) {
     path = join(path, name);
     return fileExists(path).chain((exists) {
-      if (!exists) return new Future.immediate(false);
+      if (!exists) {
+        return new Future.immediate('Expected file $path does not exist.');
+      }
 
-      return readTextFile(path).transform((text) => text == contents);
+      return readTextFile(path).transform((text) {
+        if (text == contents) return null;
+
+        return 'File $path should contain:\n\n$contents\n\n'
+               'but contained:\n\n$text';
+      });
     });
   }
 }
 
 /**
  * Describes a directory and its contents. These are used both for setting up
  * an expected directory tree before running a test, and for validating that
  * the file system matches some expectations after running it.
  */
 class DirectoryDescriptor extends Descriptor {
@@ skipping 27 matching lines @@
 
     return completer.future;
   }
 
   /**
    * Validates that the directory at [path] contains all of the expected
    * contents in this descriptor. Note that this does *not* check that the
    * directory doesn't contain other unexpected stuff, just that it *does*
    * contain the stuff we do expect.
    */
-  Future<bool> validate(String path) {
+  Future<String> validate(String path) {
     // Validate each of the items in this directory.
     final entryFutures = contents.map(
         (entry) => entry.validate(join(path, name)));
 
     // If they are all valid, the directory is valid.
     return Futures.wait(entryFutures).transform((entries) {
-      return !entries.some((valid) => !valid);
+      for (final entry in entries) {
+        if (entry != null) return entry;
+      }
+
+      // If we got here, all of the sub-entries were valid.
+      return null;
     });
   }
 }