Change Directory.create to not fail on existing directory with that name.

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:io");
 #import("dart:isolate");
 
 class DirectoryTest {
   static void testListing() {
     bool listedDir = false;
     bool listedFile = false;
 
     Directory directory = new Directory("").createTempSync();
     Directory subDirectory = new Directory("${directory.path}/subdir");
     Expect.isFalse(subDirectory.existsSync());
     subDirectory.createSync();
+    Expect.isTrue(subDirectory.existsSync());
     File f = new File('${subDirectory.path}/file.txt');
     Expect.isFalse(f.existsSync());
     f.createSync();
 
     var lister = directory.list(recursive: true);
 
     lister.onDir = (dir) {
       listedDir = true;
       Expect.isTrue(dir.contains(directory.path));
       Expect.isTrue(dir.contains('subdir'));
@@ skipping 423 matching lines @@
 testCreateTempError() {
   var location = illegalTempDirectoryLocation();
   if (location == null) return;
 
   var port = new ReceivePort();
   var future = new Directory(location).createTemp();
   future.handleException((e) => port.close());
 }
 
 
+testCreateExistingSync() {
+  // Test that creating an existing directory succeeds.
+  var d = new Directory('');
+  var temp = d.createTempSync();
+  var subDir = new Directory('${temp.path}/flaf');
+  Expect.isFalse(subDir.existsSync());
+  subDir.createSync();
+  Expect.isTrue(subDir.existsSync());
+  subDir.createSync();
+  Expect.isTrue(subDir.existsSync());
+  temp.deleteRecursivelySync();
+}
+
+
+testCreateExisting() {
+  // Test that creating an existing directory succeeds.
+  var port = new ReceivePort();
+  var d = new Directory('');
+  d.createTemp().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.deleteRecursively().then((_) {
+                port.close();
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+}
+
+
+testCreateDirExistingFileSync() {
+  // Test that creating an existing directory succeeds.
+  var d = new Directory('');
+  var temp = d.createTempSync();
+  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 DirectoryIOException);
+  temp.deleteRecursivelySync();
+}
+
+
+testCreateDirExistingFile() {
+  // Test that creating an existing directory succeeds.
+  var port = new ReceivePort();
+  var d = new Directory('');
+  d.createTemp().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"); })
+        ..handleException((e) {
+            Expect.isTrue(e is DirectoryIOException);
+            temp.deleteRecursively().then((_) {
+              port.close();
+            });
+            return true;
+          });
+    });
+  });
+}
+
+
 testRename() {
   var d = new Directory('');
   var temp1 = d.createTempSync();
   var temp2 = d.createTempSync();
   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.deleteRecursivelySync();
   });
 }
 
 main() {
   DirectoryTest.testMain();
   NestedTempDirectoryTest.testMain();
   testCreateTempErrorSync();
   testCreateTempError();
+  testCreateExistingSync();
+  testCreateExisting();
+  testCreateDirExistingFileSync();
+  testCreateDirExistingFile();
   testRename();
 }