Modify tests to use Directory.systemTemp

tests/standalone/io/directory_test.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.
 //
 // Directory listing test.
 
 import "dart:async";
 import "dart:io";
 
 import "package:async_helper/async_helper.dart";
 import "package:expect/expect.dart";
 
 class DirectoryTest {
   static void testListing() {
     bool listedDir = false;
     bool listedFile = false;
 
-    Directory directory = new Directory("").createTempSync();
+    Directory directory =
+        Directory.systemTemp.createTempSync('dart_directory_test');
     Directory subDirectory = new Directory("${directory.path}/subdir");
     Expect.isTrue('$directory'.contains(directory.path));
     Expect.isFalse(subDirectory.existsSync());
     subDirectory.createSync();
     Expect.isTrue(subDirectory.existsSync());
     File f = new File('${subDirectory.path}/file.txt');
     File fLong = new File('${directory.path}/subdir/../subdir/file.txt');
     Expect.isFalse(f.existsSync());
     f.createSync();
 
@@ skipping 51 matching lines @@
           });
         });
 
     // Listing is asynchronous, so nothing should be listed at this
     // point.
     Expect.isFalse(listedDir);
     Expect.isFalse(listedFile);
   }
 
   static void testListingTailingPaths() {
-    Directory directory = new Directory("").createTempSync();
+    Directory directory =
+        Directory.systemTemp.createTempSync('dart_directory_test');
     Directory subDirectory = new Directory("${directory.path}/subdir/");
     subDirectory.createSync();
     File f = new File('${subDirectory.path}/file.txt');
     f.createSync();
 
     void test(entry) {
       Expect.isFalse(entry.path.contains(new RegExp('[\\/][\\/]')));
     }
 
     subDirectory.listSync().forEach(test);
 
     subDirectory.list().listen(test, onDone: () {
       directory.deleteSync(recursive: true);
     });
   }
 
   static void testListNonExistent() {
     setupListerHandlers(Stream<FileSystemEntity> stream) {
       stream.listen(
           (_) => Expect.fail("Listing of non-existing directory should fail"),
           onError: (error) {
             Expect.isTrue(error is DirectoryException);
           });
     }
-    new Directory("").createTemp().then((d) {
+    Directory.systemTemp.createTemp('dart_directory').then((d) {
       d.delete().then((ignore) {
         setupListerHandlers(d.list());
         setupListerHandlers(d.list(recursive: true));
       });
     });
   }
 
   static void testListTooLongName() {
-    new Directory("").createTemp().then((d) {
+    Directory.systemTemp.createTemp('dart_directory').then((d) {
       var errors = 0;
       asyncStart();
       setupListHandlers(Stream<FileSystemEntity> stream) {
         stream.listen(
           (_) => Expect.fail("Listing of non-existing directory should fail"),
           onError: (error) {
             Expect.isTrue(error is DirectoryException);
             if (++errors == 2) {
               d.delete(recursive: true).then((_) {
                 asyncEnd();
@@ skipping 21 matching lines @@
   static void testDeleteNonExistent() {
     // Test that deleting a non-existing directory fails.
     setupFutureHandlers(future) {
       future.then((ignore) {
         Expect.fail("Deletion of non-existing directory should fail");
       }).catchError((error) {
         Expect.isTrue(error is DirectoryException);
       });
     }
 
-    new Directory("").createTemp().then((d) {
+    Directory.systemTemp.createTemp('dart_directory').then((d) {
       d.delete().then((ignore) {
         setupFutureHandlers(d.delete());
         setupFutureHandlers(d.delete(recursive: true));
       });
     });
   }
 
   static void testDeleteTooLongName() {
     asyncStart();
-    new Directory("").createTemp().then((d) {
+    Directory.systemTemp.createTemp('dart_directory').then((d) {
       var subDirName = 'subdir';
       var subDir = new Directory("${d.path}/$subDirName");
       subDir.create().then((ignore) {
           // Construct a long string of the form
           // 'tempdir/subdir/../subdir/../subdir'.
           var buffer = new StringBuffer();
           buffer.write(subDir.path);
           for (var i = 0; i < 1000; i++) {
             buffer.write("/../${subDirName}");
           }
           var long = new Directory("${buffer.toString()}");
           var errors = 0;
           onError(error) {
             Expect.isTrue(error is DirectoryException);
             if (++errors == 2) {
               d.delete(recursive: true).then((_) => asyncEnd());
             }
             return true;
           }
           long.delete().catchError(onError);
           long.delete(recursive: true).catchError(onError);
         });
     });
   }
 
   static void testDeleteNonExistentSync() {
-    Directory d = new Directory("").createTempSync();
+    Directory d = Directory.systemTemp.createTempSync('dart_directory_test');
     d.deleteSync();
     Expect.throws(d.deleteSync);
     Expect.throws(() => d.deleteSync(recursive: true));
   }
 
   static void testDeleteTooLongNameSync() {
-    Directory d = new Directory("").createTempSync();
+    Directory d = Directory.systemTemp.createTempSync('dart_directory_test');
     var subDirName = 'subdir';
     var subDir = new Directory("${d.path}/$subDirName");
     subDir.createSync();
     // Construct a long string of the form
     // 'tempdir/subdir/../subdir/../subdir'.
     var buffer = new StringBuffer();
     buffer.write(subDir.path);
     for (var i = 0; i < 1000; i++) {
       buffer.write("/../${subDirName}");
     }
     var long = new Directory("${buffer.toString()}");
     Expect.throws(long.deleteSync);
     Expect.throws(() => long.deleteSync(recursive: true));
     d.deleteSync(recursive: true);
   }
 
   static void testExistsCreateDelete() {
-    new Directory("").createTemp().then((d) {
+    Directory.systemTemp.createTemp('dart_directory').then((d) {
       d.exists().then((bool exists) {
         Expect.isTrue(exists);
         Directory created = new Directory("${d.path}/subdir");
         created.create().then((ignore) {
           created.exists().then((bool exists) {
             Expect.isTrue(exists);
             created.delete().then((ignore) {
               created.exists().then((bool exists) {
                 Expect.isFalse(exists);
                 d.delete().then((ignore) {
                   d.exists().then((bool exists) {
                     Expect.isFalse(exists);
                   });
                 });
               });
             });
           });
         });
       });
     });
   }
 
   static void testExistsCreateDeleteSync() {
-    Directory d = new Directory("").createTempSync();
+    Directory d = Directory.systemTemp.createTempSync('dart_directory_test');
     Directory d2 = new Directory('${d.path}/');
     Expect.isTrue(d.existsSync());
     Expect.isTrue(d2.existsSync());
     Directory created = new Directory("${d.path}/subdir");
     created.createSync();
     Expect.isTrue(created.existsSync());
     created.deleteSync();
     Expect.isFalse(created.existsSync());
     d.deleteSync();
     Expect.isFalse(d.existsSync());
   }
 
   static void testDeleteLinkSync() {
-    Directory tmp = new Directory("").createTempSync();
+    Directory tmp = Directory.systemTemp.createTempSync('dart_directory_test');
     var path = "${tmp.path}${Platform.pathSeparator}";
     Directory d = new Directory("${path}target");
     d.createSync();
     Link l = new Link("${path}symlink");
     l.createSync("${path}target");
     Expect.isTrue(d.existsSync());
     Expect.isTrue(l.existsSync());
     new Directory(l.path).deleteSync(recursive: true);
     Expect.isTrue(d.existsSync());
     Expect.isFalse(l.existsSync());
     d.deleteSync();
     Expect.isFalse(d.existsSync());
     tmp.deleteSync();
   }
 
   static void testDeleteLinkAsFileSync() {
-    Directory tmp = new Directory("").createTempSync();
+    Directory tmp = Directory.systemTemp.createTempSync('dart_directory_test');
     var path = "${tmp.path}${Platform.pathSeparator}";
     Directory d = new Directory("${path}target");
     d.createSync();
     Link l = new Link("${path}symlink");
     l.createSync("${path}target");
     Expect.isTrue(d.existsSync());
     Expect.isTrue(l.existsSync());
     new Link(l.path).deleteSync();
     Expect.isTrue(d.existsSync());
     Expect.isFalse(l.existsSync());
     d.deleteSync();
     Expect.isFalse(d.existsSync());
     tmp.deleteSync();
   }
 
   static void testDeleteBrokenLinkAsFileSync() {
-    Directory tmp = new Directory("").createTempSync();
+    Directory tmp = Directory.systemTemp.createTempSync('dart_directory_test');
     var path = "${tmp.path}${Platform.pathSeparator}";
     Directory d = new Directory("${path}target");
     d.createSync();
     Link l = new Link("${path}symlink");
     l.createSync("${path}target");
     d.deleteSync();
     Expect.isFalse(d.existsSync());
     Expect.isTrue(l.existsSync());
     new Link(l.path).deleteSync();
     Expect.isFalse(l.existsSync());
     Expect.isFalse(d.existsSync());
     tmp.deleteSync();
   }
 
   static void testListBrokenLinkSync() {
-    Directory tmp = new Directory("").createTempSync();
+    Directory tmp = Directory.systemTemp.createTempSync('dart_directory_test');
     var path = "${tmp.path}${Platform.pathSeparator}";
     Directory d = new Directory("${path}target");
     d.createSync();
     Link l = new Link("${path}symlink");
     l.createSync("${path}target");
     d.deleteSync();
     int count = 0;
     tmp.list(followLinks: true).listen(
         (file) {
           count++;
           Expect.isTrue(file is Link);
         },
         onDone: () {
           Expect.equals(1, count);
           l.deleteSync();
           tmp.deleteSync();
         });
   }
 
   static void testListLinkSync() {
-    Directory tmp = new Directory("").createTempSync();
+    Directory tmp = Directory.systemTemp.createTempSync('dart_directory_test');
     var path = "${tmp.path}${Platform.pathSeparator}";
     Directory d = new Directory("${path}target");
     d.createSync();
     Link l = new Link("${path}symlink");
     l.createSync("${path}target");
     int count = 0;
     tmp.list(followLinks: true).listen(
         (file) {
           count++;
           Expect.isTrue(file is Directory);
         },
         onDone: () {
           Expect.equals(2, count);
           l.deleteSync();
           d.deleteSync();
           tmp.deleteSync();
         });
   }
 
-  static void testCreateTemp([String template = ""]) {
-    asyncStart();
-    Directory dir = new Directory(template);
-    Future.wait([dir.createTemp(), dir.createTemp()])
-      .then((tempDirs) {
+  static void testCreateTemp() {
+    Directory base = new Directory('/tmp');
+    String template = 'dart_temp_dir';
+    if (base.existsSync()) {
+      asyncStart();
+      Future.wait([base.createTemp(template), base.createTemp(template)])
+          .then((tempDirs) {
         Expect.notEquals(tempDirs[0].path, tempDirs[1].path);
         for (Directory t in tempDirs) {
           Expect.isTrue(t.existsSync());
           t.deleteSync();
           Expect.isFalse(t.existsSync());
         }
         asyncEnd();
-      });
-  }
-
-  static void testCreateTempTemplate() {
-    if (new Directory("/tmp").existsSync()) {
-      testCreateTemp("/tmp/dart_temp_dir_");
+     });
     }
   }
 
+  static void testCreateSystemTemp() {
+    String template = 'dart_system_temp_dir';
+    asyncStart();
+    Future.wait([Directory.systemTemp.createTemp(template),
+                 Directory.systemTemp.createTemp(template)])
+        .then((tempDirs) {
+      Expect.notEquals(tempDirs[0].path, tempDirs[1].path);
+      for (Directory t in tempDirs) {
+        Expect.isTrue(t.existsSync());
+        t.deleteSync();
+        Expect.isFalse(t.existsSync());
+      }
+      asyncEnd();
+    });
+  }
+
   static void testCreateDeleteTemp() {
-    new Directory("").createTemp().then((tempDirectory) {
+    Directory.systemTemp.createTemp('dart_directory').then((tempDirectory) {
       String filename =
           "${tempDirectory.path}${Platform.pathSeparator}dart_testfile";
       File file = new File(filename);
       Expect.isFalse(file.existsSync());
       file.create().then((ignore) {
         file.exists().then((exists) {
           Expect.isTrue(exists);
           // Try to delete the directory containing the file - should throw.
           Expect.throws(tempDirectory.deleteSync);
           Expect.isTrue(tempDirectory.existsSync());
@@ skipping 33 matching lines @@
     testDeleteNonExistentSync();
     testDeleteTooLongNameSync();
     testExistsCreateDelete();
     testExistsCreateDeleteSync();
     testDeleteLinkSync();
     testDeleteLinkAsFileSync();
     testDeleteBrokenLinkAsFileSync();
     testListBrokenLinkSync();
     testListLinkSync();
     testCreateTemp();
+    testCreateSystemTemp();
     testCreateDeleteTemp();
     testCurrent();
     testEquals();
   }
 }
 
 
 class NestedTempDirectoryTest {
   List<Directory> createdDirectories;
   Directory current;
 
   NestedTempDirectoryTest.run()
       : createdDirectories = new List<Directory>() {
-    new Directory("").createTemp().then(createPhaseCallback);
+    Directory.systemTemp.createTemp('dart_directory').then(createPhaseCallback);
   }
 
   void createPhaseCallback(temp) {
     createdDirectories.add(temp);
     int nestingDepth = 6;
     var os = Platform.operatingSystem;
     if (os == "windows") nestingDepth = 2;
     if (createdDirectories.length < nestingDepth) {
       temp.createTemp('nested_temp_dir_${createdDirectories.length}_')
           .then(createPhaseCallback);
@@ skipping 26 matching lines @@
   if (os == "windows") {
     return "*";
   }
   return null;
 }
 
 
 testCreateTempErrorSync() {
   var location = illegalTempDirectoryLocation();
   if (location != null) {
-    Expect.throws(new Directory(location).createTempSync,
+    Expect.throws(() => new Directory(location).createTempSync('dart_tempdir'),
                   (e) => e is DirectoryException);
   }
 }
 
 
 testCreateTempError() {
   var location = illegalTempDirectoryLocation();
   if (location == null) return;
 
   asyncStart();
-  var future = new Directory(location).createTemp();
+  var future = new Directory(location).createTemp('dart_tempdir');
   future.catchError((_) => asyncEnd());
 }
 
 
 testCreateExistingSync() {
   // Test that creating an existing directory succeeds.
-  var d = new Directory('');
-  var temp = d.createTempSync();
+  var temp = Directory.systemTemp.createTempSync('directory_test');
   var subDir = new Directory('${temp.path}/flaf');
   Expect.isFalse(subDir.existsSync());
   subDir.createSync();
   Expect.isTrue(subDir.existsSync());
   subDir.createSync();
   Expect.isTrue(subDir.existsSync());
   temp.deleteSync(recursive: true);
 }
 
 
 testCreateExisting() {
   // Test that creating an existing directory succeeds.
   asyncStart();
-  var d = new Directory('');
-  d.createTemp().then((temp) {
+  Directory.systemTemp.createTemp('dart_directory').then((temp) {
     var subDir = new Directory('${temp.path}/flaf');
     subDir.exists().then((dirExists) {
       Expect.isFalse(dirExists);
       subDir.create().then((_) {
         subDir.exists().then((dirExists) {
           Expect.isTrue(dirExists);
           subDir.create().then((_) {
             subDir.exists().then((dirExists) {
               Expect.isTrue(dirExists);
               temp.delete(recursive: true).then((_) {
                 asyncEnd();
               });
             });
           });
         });
       });
     });
   });
 }
 
 
 testCreateDirExistingFileSync() {
   // Test that creating an existing directory succeeds.
-  var d = new Directory('');
-  var temp = d.createTempSync();
+  var temp = Directory.systemTemp.createTempSync('directory_test');
   var path = '${temp.path}/flaf';
   var file = new File(path);
   file.createSync();
   Expect.isTrue(file.existsSync());
   Expect.throws(new Directory(path).createSync,
                 (e) => e is DirectoryException);
   temp.deleteSync(recursive: true);
 }
 
 
 testCreateDirExistingFile() {
   // Test that creating an existing directory succeeds.
   asyncStart();
-  var d = new Directory('');
-  d.createTemp().then((temp) {
+  Directory.systemTemp.createTemp('dart_directory').then((temp) {
     var path = '${temp.path}/flaf';
     var file = new File(path);
     var subDir = new Directory(path);
     file.create().then((_) {
       subDir.create()
         .then((_) { Expect.fail("dir create should fail on existing file"); })
         .catchError((error) {
           Expect.isTrue(error is DirectoryException);
           temp.delete(recursive: true).then((_) {
             asyncEnd();
           });
         });
     });
   });
 }
 
 
 testCreateRecursiveSync() {
-  var temp = new Directory('').createTempSync();
+  var temp = Directory.systemTemp.createTempSync('directory_test');
   var d = new Directory('${temp.path}/a/b/c');
   d.createSync(recursive: true);
   Expect.isTrue(new Directory('${temp.path}/a').existsSync());
   Expect.isTrue(new Directory('${temp.path}/a/b').existsSync());
   Expect.isTrue(new Directory('${temp.path}/a/b/c').existsSync());
   temp.deleteSync(recursive: true);
 }
 
 
 testCreateRecursive() {
   asyncStart();
-  new Directory('').createTemp().then((temp) {
+  Directory.systemTemp.createTemp('dart_directory').then((temp) {
     var d = new Directory('${temp.path}/a/b/c');
     d.create(recursive: true).then((_) {
       Expect.isTrue(new Directory('${temp.path}/a').existsSync());
       Expect.isTrue(new Directory('${temp.path}/a/b').existsSync());
       Expect.isTrue(new Directory('${temp.path}/a/b/c').existsSync());
       temp.deleteSync(recursive: true);
       asyncEnd();
     });
   });
 }
 
 
 testRename() {
-  var d = new Directory('');
-  var temp1 = d.createTempSync();
-  var temp2 = d.createTempSync();
+  var temp1 = Directory.systemTemp.createTempSync('directory_test');
+  var temp2 = Directory.systemTemp.createTempSync('directory_test');
   var temp3 = temp1.renameSync(temp2.path);
   Expect.isFalse(temp1.existsSync());
   Expect.isTrue(temp2.existsSync());
   Expect.equals(temp3.path, temp2.path);
 
   temp2.rename(temp1.path).then((temp4) {
     Expect.isFalse(temp3.existsSync());
     Expect.isFalse(temp2.existsSync());
     Expect.isTrue(temp1.existsSync());
     Expect.isTrue(temp4.existsSync());
     Expect.equals(temp1.path, temp4.path);
     temp1.deleteSync(recursive: true);
   });
 }
 
 main() {
   DirectoryTest.testMain();
   NestedTempDirectoryTest.testMain();
   testCreateTempErrorSync();
   testCreateTempError();
   testCreateExistingSync();
   testCreateExisting();
   testCreateDirExistingFileSync();
   testCreateDirExistingFile();
   testCreateRecursive();
   testCreateRecursiveSync();
   testRename();
 }