Add vectortile branch

2015-09-10 15:23:57 +02:00
parent 57ee7f52fd
commit 962473c3ab
3201 changed files with 978141 additions and 0 deletions
@@ -0,0 +1,752 @@
+// Copyright 2011 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+goog.provide('goog.fsTest');
+goog.setTestOnly('goog.fsTest');
+
+goog.require('goog.Promise');
+goog.require('goog.array');
+goog.require('goog.dom');
+goog.require('goog.events');
+goog.require('goog.fs');
+goog.require('goog.fs.DirectoryEntry');
+goog.require('goog.fs.Error');
+goog.require('goog.fs.FileReader');
+goog.require('goog.fs.FileSaver');
+goog.require('goog.string');
+goog.require('goog.testing.PropertyReplacer');
+goog.require('goog.testing.jsunit');
+
+var TEST_DIR = 'goog-fs-test-dir';
+
+var fsExists = goog.isDef(goog.global.requestFileSystem) ||
+    goog.isDef(goog.global.webkitRequestFileSystem);
+var deferredFs = fsExists ? goog.fs.getTemporary() : null;
+var stubs = new goog.testing.PropertyReplacer();
+
+function setUpPage() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadTestDir().then(null, function(err) {
+    var msg;
+    if (err.code == goog.fs.Error.ErrorCode.QUOTA_EXCEEDED) {
+      msg = err.message + '. If you\'re using Chrome, you probably need to ' +
+          'pass --unlimited-quota-for-files on the command line.';
+    } else if (err.code == goog.fs.Error.ErrorCode.SECURITY &&
+               window.location.href.match(/^file:/)) {
+      msg = err.message + '. file:// URLs can\'t access the filesystem API.';
+    } else {
+      msg = err.message;
+    }
+    var body = goog.dom.getDocument().body;
+    goog.dom.insertSiblingBefore(
+        goog.dom.createDom('h1', {}, msg), body.childNodes[0]);
+  });
+}
+
+function tearDown() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadTestDir().then(function(dir) { return dir.removeRecursively(); });
+}
+
+function testUnavailableTemporaryFilesystem() {
+  stubs.set(goog.global, 'requestFileSystem', null);
+  stubs.set(goog.global, 'webkitRequestFileSystem', null);
+
+  return goog.fs.getTemporary(1024).then(fail, function(e) {
+    assertEquals('File API unsupported', e.message);
+  });
+}
+
+
+function testUnavailablePersistentFilesystem() {
+  stubs.set(goog.global, 'requestFileSystem', null);
+  stubs.set(goog.global, 'webkitRequestFileSystem', null);
+
+  return goog.fs.getPersistent(2048).then(fail, function(e) {
+    assertEquals('File API unsupported', e.message);
+  });
+}
+
+
+function testIsFile() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).then(
+      function(fileEntry) {
+        assertFalse(fileEntry.isDirectory());
+        assertTrue(fileEntry.isFile());
+      });
+}
+
+function testIsDirectory() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadDirectory('test', goog.fs.DirectoryEntry.Behavior.CREATE).then(
+      function(fileEntry) {
+        assertTrue(fileEntry.isDirectory());
+        assertFalse(fileEntry.isFile());
+      });
+}
+
+function testReadFileUtf16() {
+  if (!fsExists) {
+    return;
+  }
+  var str = 'test content';
+  var buf = new ArrayBuffer(str.length * 2);
+  var arr = new Uint16Array(buf);
+  for (var i = 0; i < str.length; i++) {
+    arr[i] = str.charCodeAt(i);
+  }
+
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(goog.partial(writeToFile, arr.buffer)).
+      then(goog.partial(checkFileContentWithEncoding, str, 'UTF-16'));
+}
+
+function testReadFileUtf8() {
+  if (!fsExists) {
+    return;
+  }
+  var str = 'test content';
+  var buf = new ArrayBuffer(str.length);
+  var arr = new Uint8Array(buf);
+  for (var i = 0; i < str.length; i++) {
+    arr[i] = str.charCodeAt(i) & 0xff;
+  }
+
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(goog.partial(writeToFile, arr.buffer)).
+      then(goog.partial(checkFileContentWithEncoding, str, 'UTF-8'));
+}
+
+function testReadFileAsArrayBuffer() {
+  if (!fsExists) {
+    return;
+  }
+  var str = 'test content';
+  var buf = new ArrayBuffer(str.length);
+  var arr = new Uint8Array(buf);
+  for (var i = 0; i < str.length; i++) {
+    arr[i] = str.charCodeAt(i) & 0xff;
+  }
+
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(goog.partial(writeToFile, arr.buffer)).
+      then(goog.partial(checkFileContentAs, arr.buffer, 'ArrayBuffer',
+          undefined));
+}
+
+function testReadFileAsBinaryString() {
+  if (!fsExists) {
+    return;
+  }
+  var str = 'test content';
+  var buf = new ArrayBuffer(str.length);
+  var arr = new Uint8Array(buf);
+  for (var i = 0; i < str.length; i++) {
+    arr[i] = str.charCodeAt(i);
+  }
+
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(goog.partial(writeToFile, arr.buffer)).
+      then(goog.partial(checkFileContentAs, str, 'BinaryString', undefined));
+}
+
+function testWriteFile() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(goog.partial(writeToFile, 'test content')).
+      then(goog.partial(checkFileContent, 'test content'));
+}
+
+function testRemoveFile() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(goog.partial(writeToFile, 'test content')).
+      then(function(file) { return file.remove(); }).
+      then(goog.partial(checkFileRemoved, 'test'));
+}
+
+function testMoveFile() {
+  if (!fsExists) {
+    return;
+  }
+
+  var deferredSubdir = loadDirectory(
+      'subdir', goog.fs.DirectoryEntry.Behavior.CREATE);
+  var deferredWrittenFile =
+      loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(goog.partial(writeToFile, 'test content'));
+  return goog.Promise.all([deferredSubdir, deferredWrittenFile]).
+      then(splitArgs(function(dir, file) { return file.moveTo(dir); })).
+      then(goog.partial(checkFileContent, 'test content')).
+      then(goog.partial(checkFileRemoved, 'test'));
+}
+
+function testCopyFile() {
+  if (!fsExists) {
+    return;
+  }
+
+  var deferredFile = loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE);
+  var deferredSubdir = loadDirectory(
+      'subdir', goog.fs.DirectoryEntry.Behavior.CREATE);
+  var deferredWrittenFile = deferredFile.then(
+      goog.partial(writeToFile, 'test content'));
+  return goog.Promise.all([deferredSubdir, deferredWrittenFile]).
+      then(splitArgs(function(dir, file) { return file.copyTo(dir); })).
+      then(goog.partial(checkFileContent, 'test content')).
+      then(function() { return deferredFile; }).
+      then(goog.partial(checkFileContent, 'test content'));
+}
+
+function testAbortWrite() {
+  // TODO(nicksantos): This test is broken in newer versions of chrome.
+  // We don't know why yet.
+  if (true) return;
+
+  if (!fsExists) {
+    return;
+  }
+
+  var deferredFile = loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE);
+  return deferredFile.
+      then(goog.partial(startWrite, 'test content')).
+      then(function(writer) {
+        return new goog.Promise(function(resolve) {
+          goog.events.listenOnce(
+              writer, goog.fs.FileSaver.EventType.ABORT, resolve);
+          writer.abort();
+        });
+      }).
+      then(function() { return loadFile('test'); }).
+      then(goog.partial(checkFileContent, ''));
+}
+
+function testSeek() {
+  if (!fsExists) {
+    return;
+  }
+
+  var deferredFile = loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE);
+  return deferredFile.
+      then(goog.partial(writeToFile, 'test content')).
+      then(function(file) { return file.createWriter(); }).
+      then(
+          goog.partial(checkReadyState, goog.fs.FileSaver.ReadyState.INIT)).
+      then(function(writer) {
+        writer.seek(5);
+        writer.write(goog.fs.getBlob('stuff and things'));
+        return writer;
+      }).
+      then(
+          goog.partial(checkReadyState, goog.fs.FileSaver.ReadyState.WRITING)).
+      then(
+          goog.partial(waitForEvent, goog.fs.FileSaver.EventType.WRITE)).
+      then(function() { return deferredFile; }).
+      then(goog.partial(checkFileContent, 'test stuff and things'));
+}
+
+function testTruncate() {
+  if (!fsExists) {
+    return;
+  }
+
+  var deferredFile = loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE);
+  return deferredFile.
+      then(goog.partial(writeToFile, 'test content')).
+      then(function(file) { return file.createWriter(); }).
+      then(goog.partial(checkReadyState, goog.fs.FileSaver.ReadyState.INIT)).
+      then(function(writer) {
+        writer.truncate(4);
+        return writer;
+      }).
+      then(
+          goog.partial(checkReadyState, goog.fs.FileSaver.ReadyState.WRITING)).
+      then(
+          goog.partial(waitForEvent, goog.fs.FileSaver.EventType.WRITE)).
+      then(function() { return deferredFile; }).
+      then(goog.partial(checkFileContent, 'test'));
+}
+
+function testGetLastModified() {
+  if (!fsExists) {
+    return;
+  }
+  var now = goog.now();
+  return loadFile('test', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(function(entry) { return entry.getLastModified(); }).
+      then(function(date) {
+        assertRoughlyEquals('Expected the last modified date to be within ' +
+           'a few milliseconds of the test start time.',
+           now, date.getTime(), 2000);
+      });
+}
+
+function testCreatePath() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadTestDir().
+      then(function(testDir) {
+        return testDir.createPath('foo');
+      }).
+      then(function(fooDir) {
+        assertEquals('/goog-fs-test-dir/foo', fooDir.getFullPath());
+        return fooDir.createPath('bar/baz/bat');
+      }).
+      then(function(batDir) {
+        assertEquals('/goog-fs-test-dir/foo/bar/baz/bat', batDir.getFullPath());
+      });
+}
+
+function testCreateAbsolutePath() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadTestDir().
+      then(function(testDir) {
+        return testDir.createPath('/' + TEST_DIR + '/fee/fi/fo/fum');
+      }).
+      then(function(absDir) {
+        assertEquals('/goog-fs-test-dir/fee/fi/fo/fum', absDir.getFullPath());
+      });
+}
+
+function testCreateRelativePath() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadTestDir().
+      then(function(dir) {
+        return dir.createPath('../' + TEST_DIR + '/dir');
+      }).
+      then(function(relDir) {
+        assertEquals('/goog-fs-test-dir/dir', relDir.getFullPath());
+        return relDir.createPath('.');
+      }).
+      then(function(sameDir) {
+        assertEquals('/goog-fs-test-dir/dir', sameDir.getFullPath());
+        return sameDir.createPath('./././.');
+      }).
+      then(function(reallySameDir) {
+        assertEquals('/goog-fs-test-dir/dir', reallySameDir.getFullPath());
+        return reallySameDir.createPath('./new/../..//dir/./new////.');
+      }).
+      then(function(newDir) {
+        assertEquals('/goog-fs-test-dir/dir/new', newDir.getFullPath());
+      });
+}
+
+function testCreateBadPath() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadTestDir().
+      then(function() { return loadTestDir(); }).
+      then(function(dir) {
+        // There is only one layer of parent directory from the test dir.
+        return dir.createPath('../../../../' + TEST_DIR + '/baz/bat');
+      }).
+      then(function(batDir) {
+        assertEquals('The parent directory of the root directory should ' +
+                     'point back to the root directory.',
+                     '/goog-fs-test-dir/baz/bat', batDir.getFullPath());
+      }).
+
+      then(function() { return loadTestDir(); }).
+      then(function(dir) {
+        // An empty path should return the same as the input directory.
+        return dir.createPath('');
+      }).
+      then(function(testDir) {
+        assertEquals('/goog-fs-test-dir', testDir.getFullPath());
+      });
+}
+
+function testGetAbsolutePaths() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadFile('foo', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(function() { return loadTestDir(); }).
+      then(function(testDir) { return testDir.getDirectory('/'); }).
+      then(function(root) {
+        assertEquals('/', root.getFullPath());
+        return root.getDirectory('/' + TEST_DIR);
+      }).
+      then(function(testDir) {
+        assertEquals('/goog-fs-test-dir', testDir.getFullPath());
+        return testDir.getDirectory('//' + TEST_DIR + '////');
+      }).
+      then(function(testDir) {
+        assertEquals('/goog-fs-test-dir', testDir.getFullPath());
+        return testDir.getDirectory('////');
+      }).
+      then(function(testDir) { assertEquals('/', testDir.getFullPath()); });
+}
+
+
+function testListEmptyDirectory() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadTestDir().
+      then(function(dir) { return dir.listDirectory(); }).
+      then(function(entries) { assertArrayEquals([], entries); });
+}
+
+
+function testListDirectory() {
+  if (!fsExists) {
+    return;
+  }
+
+  return loadDirectory('testDir', goog.fs.DirectoryEntry.Behavior.CREATE).
+      then(function() {
+        return loadFile('testFile', goog.fs.DirectoryEntry.Behavior.CREATE);
+      }).
+      then(function() { return loadTestDir(); }).
+      then(function(testDir) { return testDir.listDirectory(); }).
+      then(function(entries) {
+        // Verify the contents of the directory listing.
+        assertEquals(2, entries.length);
+
+        var dir = goog.array.find(entries, function(entry) {
+          return entry.getName() == 'testDir';
+        });
+        assertNotNull(dir);
+        assertTrue(dir.isDirectory());
+
+        var file = goog.array.find(entries, function(entry) {
+          return entry.getName() == 'testFile';
+        });
+        assertNotNull(file);
+        assertTrue(file.isFile());
+      });
+}
+
+
+function testListBigDirectory() {
+  // TODO(nicksantos): This test is broken in newer versions of chrome.
+  // We don't know why yet.
+  if (true) return;
+
+  if (!fsExists) {
+    return;
+  }
+
+  function getFileName(i) {
+    return 'file' + goog.string.padNumber(i, String(count).length);
+  }
+
+  // NOTE: This was intended to verify that the results from repeated
+  // DirectoryReader.readEntries() callbacks are appropriately concatenated.
+  // In current versions of Chrome (March 2011), all results are returned in the
+  // first callback regardless of directory size. The count can be increased in
+  // the future to test batched result lists once they are implemented.
+  var count = 100;
+
+  var expectedNames = [];
+
+  var def = goog.Promise.resolve();
+  for (var i = 0; i < count; i++) {
+    var name = getFileName(i);
+    expectedNames.push(name);
+
+    def.then(function() {
+      return loadFile(name, goog.fs.DirectoryEntry.Behavior.CREATE);
+    });
+  }
+
+  return def.then(function() { return loadTestDir(); }).
+      then(function(testDir) { return testDir.listDirectory(); }).
+      then(function(entries) {
+        assertEquals(count, entries.length);
+
+        assertSameElements(expectedNames,
+                           goog.array.map(entries, function(entry) {
+                             return entry.getName();
+                           }));
+        assertTrue(goog.array.every(entries, function(entry) {
+          return entry.isFile();
+        }));
+      });
+}
+
+
+function testSliceBlob() {
+  // A mock blob object whose slice returns the parameters it was called with.
+  var blob = {
+    'size': 10,
+    'slice': function(start, end) {
+      return [start, end];
+    }
+  };
+
+  // Simulate Firefox 13 that implements the new slice.
+  var tmpStubs = new goog.testing.PropertyReplacer();
+  tmpStubs.set(goog.userAgent, 'GECKO', true);
+  tmpStubs.set(goog.userAgent, 'WEBKIT', false);
+  tmpStubs.set(goog.userAgent, 'IE', false);
+  tmpStubs.set(goog.userAgent, 'VERSION', '13.0');
+  tmpStubs.set(goog.userAgent, 'isVersionOrHigherCache_', {});
+
+  // Expect slice to be called with no change to parameters
+  assertArrayEquals([2, 10], goog.fs.sliceBlob(blob, 2));
+  assertArrayEquals([-2, 10], goog.fs.sliceBlob(blob, -2));
+  assertArrayEquals([3, 6], goog.fs.sliceBlob(blob, 3, 6));
+  assertArrayEquals([3, -6], goog.fs.sliceBlob(blob, 3, -6));
+
+  // Simulate IE 10 that implements the new slice.
+  var tmpStubs = new goog.testing.PropertyReplacer();
+  tmpStubs.set(goog.userAgent, 'GECKO', false);
+  tmpStubs.set(goog.userAgent, 'WEBKIT', false);
+  tmpStubs.set(goog.userAgent, 'IE', true);
+  tmpStubs.set(goog.userAgent, 'VERSION', '10.0');
+  tmpStubs.set(goog.userAgent, 'isVersionOrHigherCache_', {});
+
+  // Expect slice to be called with no change to parameters
+  assertArrayEquals([2, 10], goog.fs.sliceBlob(blob, 2));
+  assertArrayEquals([-2, 10], goog.fs.sliceBlob(blob, -2));
+  assertArrayEquals([3, 6], goog.fs.sliceBlob(blob, 3, 6));
+  assertArrayEquals([3, -6], goog.fs.sliceBlob(blob, 3, -6));
+
+  // Simulate Firefox 4 that implements the old slice.
+  tmpStubs.set(goog.userAgent, 'GECKO', true);
+  tmpStubs.set(goog.userAgent, 'WEBKIT', false);
+  tmpStubs.set(goog.userAgent, 'IE', false);
+  tmpStubs.set(goog.userAgent, 'VERSION', '2.0');
+  tmpStubs.set(goog.userAgent, 'isVersionOrHigherCache_', {});
+
+  // Expect slice to be called with transformed parameters.
+  assertArrayEquals([2, 8], goog.fs.sliceBlob(blob, 2));
+  assertArrayEquals([8, 2], goog.fs.sliceBlob(blob, -2));
+  assertArrayEquals([3, 3], goog.fs.sliceBlob(blob, 3, 6));
+  assertArrayEquals([3, 1], goog.fs.sliceBlob(blob, 3, -6));
+
+  // Simulate Firefox 5 that implements mozSlice (new spec).
+  delete blob.slice;
+  blob.mozSlice = function(start, end) {
+    return ['moz', start, end];
+  };
+  tmpStubs.set(goog.userAgent, 'GECKO', true);
+  tmpStubs.set(goog.userAgent, 'WEBKIT', false);
+  tmpStubs.set(goog.userAgent, 'IE', false);
+  tmpStubs.set(goog.userAgent, 'VERSION', '5.0');
+  tmpStubs.set(goog.userAgent, 'isVersionOrHigherCache_', {});
+
+  // Expect mozSlice to be called with no change to parameters.
+  assertArrayEquals(['moz', 2, 10], goog.fs.sliceBlob(blob, 2));
+  assertArrayEquals(['moz', -2, 10], goog.fs.sliceBlob(blob, -2));
+  assertArrayEquals(['moz', 3, 6], goog.fs.sliceBlob(blob, 3, 6));
+  assertArrayEquals(['moz', 3, -6], goog.fs.sliceBlob(blob, 3, -6));
+
+  // Simulate Chrome 20 that implements webkitSlice (new spec).
+  delete blob.mozSlice;
+  blob.webkitSlice = function(start, end) {
+    return ['webkit', start, end];
+  };
+  tmpStubs.set(goog.userAgent, 'GECKO', false);
+  tmpStubs.set(goog.userAgent, 'WEBKIT', true);
+  tmpStubs.set(goog.userAgent, 'IE', false);
+  tmpStubs.set(goog.userAgent, 'VERSION', '536.10');
+  tmpStubs.set(goog.userAgent, 'isVersionOrHigherCache_', {});
+
+  // Expect webkitSlice to be called with no change to parameters.
+  assertArrayEquals(['webkit', 2, 10], goog.fs.sliceBlob(blob, 2));
+  assertArrayEquals(['webkit', -2, 10], goog.fs.sliceBlob(blob, -2));
+  assertArrayEquals(['webkit', 3, 6], goog.fs.sliceBlob(blob, 3, 6));
+  assertArrayEquals(['webkit', 3, -6], goog.fs.sliceBlob(blob, 3, -6));
+
+  tmpStubs.reset();
+}
+
+
+function testGetBlobThrowsError() {
+  stubs.remove(goog.global, 'BlobBuilder');
+  stubs.remove(goog.global, 'WebKitBlobBuilder');
+  stubs.remove(goog.global, 'Blob');
+
+  try {
+    goog.fs.getBlob();
+    fail();
+  } catch (e) {
+    assertEquals('This browser doesn\'t seem to support creating Blobs',
+        e.message);
+  }
+
+  stubs.reset();
+}
+
+
+function testGetBlobWithProperties() {
+  // Skip test if browser doesn't support Blob API.
+  if (typeof(goog.global.Blob) != 'function') {
+    return;
+  }
+
+  var blob = goog.fs.getBlobWithProperties(['test'], 'text/test', 'native');
+  assertEquals('text/test', blob.type);
+}
+
+
+function testGetBlobWithPropertiesThrowsError() {
+  stubs.remove(goog.global, 'BlobBuilder');
+  stubs.remove(goog.global, 'WebKitBlobBuilder');
+  stubs.remove(goog.global, 'Blob');
+
+  try {
+    goog.fs.getBlobWithProperties();
+    fail();
+  } catch (e) {
+    assertEquals('This browser doesn\'t seem to support creating Blobs',
+        e.message);
+  }
+
+  stubs.reset();
+}
+
+
+function testGetBlobWithPropertiesUsingBlobBuilder() {
+  function BlobBuilder() {
+    this.parts = [];
+    this.append = function(value, endings) {
+      this.parts.push({value: value, endings: endings});
+    };
+    this.getBlob = function(type) {
+      return {type: type, builder: this};
+    };
+  }
+  stubs.set(goog.global, 'BlobBuilder', BlobBuilder);
+
+  var blob = goog.fs.getBlobWithProperties(['test'], 'text/test', 'native');
+  assertEquals('text/test', blob.type);
+  assertEquals('test', blob.builder.parts[0].value);
+  assertEquals('native', blob.builder.parts[0].endings);
+
+  stubs.reset();
+}
+
+
+function loadTestDir() {
+  return deferredFs.then(function(fs) {
+    return fs.getRoot().getDirectory(
+        TEST_DIR, goog.fs.DirectoryEntry.Behavior.CREATE);
+  });
+}
+
+function loadFile(filename, behavior) {
+  return loadTestDir().then(function(dir) {
+    return dir.getFile(filename, behavior);
+  });
+}
+
+function loadDirectory(filename, behavior) {
+  return loadTestDir().then(function(dir) {
+    return dir.getDirectory(filename, behavior);
+  });
+}
+
+function startWrite(content, file) {
+  return file.createWriter().
+      then(goog.partial(checkReadyState, goog.fs.FileSaver.ReadyState.INIT)).
+      then(function(writer) {
+        writer.write(goog.fs.getBlob(content));
+        return writer;
+      }).
+      then(goog.partial(checkReadyState, goog.fs.FileSaver.ReadyState.WRITING));
+}
+
+function waitForEvent(type, target) {
+  var done;
+  var promise = new goog.Promise(function(_done) { done = _done; });
+  goog.events.listenOnce(target, type, done);
+  return promise;
+}
+
+function writeToFile(content, file) {
+  return startWrite(content, file).
+      then(goog.partial(waitForEvent, goog.fs.FileSaver.EventType.WRITE)).
+      then(function() { return file; });
+}
+
+function checkFileContent(content, file) {
+  return checkFileContentAs(content, 'Text', undefined, file);
+}
+
+function checkFileContentWithEncoding(content, encoding, file) {
+  return checkFileContentAs(content, 'Text', encoding, file);
+}
+
+function checkFileContentAs(content, filetype, encoding, file) {
+  return file.file().
+      then(function(blob) {
+        return goog.fs.FileReader['readAs' + filetype](blob, encoding);
+      }).
+      then(goog.partial(checkEquals, content));
+}
+
+function checkEquals(a, b) {
+  if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) {
+    assertEquals(a.byteLength, b.byteLength);
+    var viewA = new DataView(a);
+    var viewB = new DataView(b);
+    for (var i = 0; i < a.byteLength; i++) {
+      assertEquals(viewA.getUint8(i), viewB.getUint8(i));
+    }
+  } else {
+    assertEquals(a, b);
+  }
+}
+
+function checkFileRemoved(filename) {
+  return loadFile(filename).then(
+      goog.partial(fail, 'expected file to be removed'),
+      function(err) {
+        assertEquals(err.code, goog.fs.Error.ErrorCode.NOT_FOUND);
+      });
+}
+
+function checkReadyState(expectedState, writer) {
+  assertEquals(expectedState, writer.getReadyState());
+  return writer;
+}
+
+function splitArgs(fn) {
+  return function(args) { return fn(args[0], args[1]); };
+}