[dart:io] Adds functions to set file access and modification time

tests/standalone/io/file_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.
 //
 // Dart test program for testing file I/O.
 
 // OtherResources=empty_file
 // OtherResources=file_test.txt
 // OtherResources=fixed_length_file
 // OtherResources=read_as_text.dat
@@ skipping 1243 matching lines @@
 
   static void testLastModified() {
     asyncTestStarted();
     new File(Platform.executable).lastModified().then((modified) {
       Expect.isTrue(modified is DateTime);
       Expect.isTrue(modified.isBefore(new DateTime.now()));
       asyncTestDone("testLastModified");
     });
   }
 
+  static void testLastAccessed() {
+    asyncTestStarted();
+    new File(Platform.executable).lastAccessed().then((accessed) {
+      Expect.isTrue(accessed is DateTime);
+      Expect.isTrue(accessed.isBefore(new DateTime.now()));
+      asyncTestDone("testLastAccessed");
+    });
+  }
+
   static void testDoubleAsyncOperation() {
     asyncTestStarted();
     var file = new File(Platform.executable).openSync();
     var completer = new Completer();
     int done = 0;
     bool error = false;
     void getLength() {
       file.length()
           .catchError((e) { error = true; })
           .whenComplete(() {
             if (++done == 2) {
               asyncTestDone("testDoubleAsyncOperation");
               Expect.isTrue(error);
               file.lengthSync();
               file.closeSync();
             }
           });
     }
     getLength();
     getLength();
     Expect.throws(() => file.lengthSync());
   }
 
   static void testLastModifiedSync() {
     var modified = new File(Platform.executable).lastModifiedSync();
     Expect.isTrue(modified is DateTime);
     Expect.isTrue(modified.isBefore(new DateTime.now()));
   }
 
+  static void testLastAccessedSync() {
+    var accessed = new File(Platform.executable).lastAccessedSync();

[Lasse Reichstein Nielsen, 2017/02/09 15:28:04]

Are we sure this works on all platforms?

[zra, 2017/02/09 17:21:39]

Tests pass on Linux/MacOS/Windows. Setting last accessed/modified time will fail
on some Android devices and succeed on others:

https://code.google.com/p/android/issues/detail?id=18624

Not sure we can do much there. The platform specific code builds for Fuchsia,
and we can request that it should work if it doesn't already.

+    Expect.isTrue(accessed is DateTime);
+    Expect.isTrue(accessed.isBefore(new DateTime.now()));
+  }
+
   static void testLastModifiedSyncDirectory() {
     Directory tmp = tempDirectory.createTempSync('file_last_modified_test_');
     String dirPath = '${tmp.path}/dir';
     new Directory(dirPath).createSync();
     try {
       new File(dirPath).lastModifiedSync();
       Expect.fail('Expected operation to throw');
     } catch (e) {
       if (e is! FileSystemException) {
         print(e);
       }
       Expect.isTrue(e is FileSystemException);
     } finally {
       tmp.deleteSync(recursive: true);
     }
   }
 
+  static void testLastAccessedSyncDirectory() {
+    Directory tmp = tempDirectory.createTempSync('file_last_accessed_test_');
+    String dirPath = '${tmp.path}/dir';
+    new Directory(dirPath).createSync();
+    try {
+      new File(dirPath).lastAccessedSync();
+      Expect.fail('Expected operation to throw');
+    } catch (e) {
+      if (e is! FileSystemException) {
+        print(e);
+      }
+      Expect.isTrue(e is FileSystemException);

[Lasse Reichstein Nielsen, 2017/02/09 15:28:04]

You can use:
 Expect.throws(File(dirPath).lasAccessedSync,
               (e) => e is FileSystemException));
to test the throwing.
(You still need the finally for clean-up, though).

[zra, 2017/02/09 17:21:39]

Leaving as-is for cleanup, and printing if it's the wrong exception.

+    } finally {
+      tmp.deleteSync(recursive: true);
+    }
+  }
+
+  static void testSetLastModifiedSync() {
+    String newFilePath = '${tempDirectory.path}/set_last_modified_sync_test';
+    File file = new File(newFilePath);
+    file.createSync();
+    DateTime modifiedTime = new DateTime(2016, 1, 1);
+    file.setLastModifiedSync(modifiedTime);
+    FileStat stat = file.statSync();
+    Expect.equals(2016, stat.modified.year);
+    Expect.equals(1, stat.modified.month);
+    Expect.equals(1, stat.modified.day);
+  }
+
+
+  static testSetLastModified() async {
+    asyncTestStarted();
+    String newFilePath = '${tempDirectory.path}/set_last_modified_test';
+    File file = new File(newFilePath);
+    file.createSync();
+    DateTime modifiedTime = new DateTime(2016, 1, 1);
+    await file.setLastModified(modifiedTime);
+    FileStat stat = await file.stat();
+    Expect.equals(2016, stat.modified.year);
+    Expect.equals(1, stat.modified.month);
+    Expect.equals(1, stat.modified.day);
+    asyncTestDone("testSetLastModified");
+  }
+
+
+  static void testSetLastModifiedSyncDirectory() {
+    Directory tmp = tempDirectory.createTempSync('file_last_modified_test_');
+    String dirPath = '${tmp.path}/dir';
+    new Directory(dirPath).createSync();
+    try {
+      DateTime modifiedTime = new DateTime(2016, 1, 1);
+      new File(dirPath).setLastModifiedSync(modifiedTime);
+      Expect.fail('Expected operation to throw');
+    } catch (e) {
+      if (e is! FileSystemException) {
+        print(e);
+      }
+      Expect.isTrue(e is FileSystemException);
+    } finally {
+      tmp.deleteSync(recursive: true);
+    }
+  }
+
+  static void testSetLastAccessedSync() {
+    String newFilePath = '${tempDirectory.path}/set_last_accessed_sync_test';
+    File file = new File(newFilePath);
+    file.createSync();
+    DateTime accessedTime = new DateTime(2016, 1, 1);
+    file.setLastAccessedSync(accessedTime);
+    FileStat stat = file.statSync();
+    Expect.equals(2016, stat.accessed.year);
+    Expect.equals(1, stat.accessed.month);
+    Expect.equals(1, stat.accessed.day);
+  }
+
+
+  static testSetLastAccessed() async {
+    asyncTestStarted();
+    String newFilePath = '${tempDirectory.path}/set_last_accessed_test';
+    File file = new File(newFilePath);
+    file.createSync();
+    DateTime accessedTime = new DateTime(2016, 1, 1);
+    await file.setLastAccessed(accessedTime);
+    FileStat stat = await file.stat();
+    Expect.equals(2016, stat.accessed.year);
+    Expect.equals(1, stat.accessed.month);
+    Expect.equals(1, stat.accessed.day);
+    asyncTestDone("testSetLastAccessed");
+  }
+
+
+  static void testSetLastAccessedSyncDirectory() {
+    Directory tmp = tempDirectory.createTempSync('file_last_accessed_test_');
+    String dirPath = '${tmp.path}/dir';
+    new Directory(dirPath).createSync();
+    try {
+      DateTime accessedTime = new DateTime(2016, 1, 1);
+      new File(dirPath).setLastAccessedSync(accessedTime);
+      Expect.fail('Expected operation to throw');
+    } catch (e) {
+      if (e is! FileSystemException) {
+        print(e);
+      }
+      Expect.isTrue(e is FileSystemException);
+    } finally {
+      tmp.deleteSync(recursive: true);
+    }
+  }
+
   // Test that opens the same file for writing then for appending to test
   // that the file is not truncated when opened for appending.
   static void testAppend() {
     asyncTestStarted();
     var file = new File('${tempDirectory.path}/out_append');
     file.open(mode: WRITE).then((openedFile) {
       openedFile.writeString("asdf").then((ignore) {
         openedFile.close().then((ignore) {
           file.open(mode: APPEND).then((openedFile) {
             openedFile.length().then((length) {
@@ skipping 154 matching lines @@
     testLengthSync();
     testPositionSync();
     testOpenDirectoryAsFile();
     testOpenDirectoryAsFileSync();
     testReadAsBytesSync();
     testReadAsBytesSyncEmptyFile();
     testReadAsTextSync();
     testReadAsTextSyncEmptyFile();
     testReadAsLinesSync();
     testLastModifiedSync();
+    testLastAccessedSync();
 
     createTempDirectory(() {
       testLength();
       testLengthSyncDirectory();
       testReadWrite();
       testReadWriteSync();
       testReadWriteNoArgsSync();
       testReadWriteStream();
       testReadEmptyFileSync();
       testReadEmptyFile();
@@ skipping 23 matching lines @@
       testWriteFromOffset();
       testDirectory();
       testDirectorySync();
       testWriteStringUtf8();
       testWriteStringUtf8Sync();
       testRename(targetExists: false);
       testRenameSync(targetExists: false);
       testRename(targetExists: true);
       testRenameSync(targetExists: true);
       testLastModified();
+      testLastAccessed();
       testLastModifiedSyncDirectory();
+      testLastAccessedSyncDirectory();
+      testSetLastModified();
+      testSetLastModifiedSync();
+      testSetLastModifiedSyncDirectory();
+      testSetLastAccessed();
+      testSetLastAccessedSync();
+      testSetLastAccessedSyncDirectory();
       testDoubleAsyncOperation();
       asyncEnd();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }