third_party/WebKit/LayoutTests/fast/filesystem/cross-filesystem-op.html

   1 <html>
   2 <body>
   3 <div>This tests basic cross-filesystem operations.</div>
   4
   5 <div id="destination" style="min-height:100px; border: solid 1px black">Drop files here if you test this manually</div>
   6
   7 <div id="console"></div>
   8
   9 <script>
  10 var methods = [ 'copyTo', 'moveTo' ];
  11 var sourceTestDirectory, destTestDirectory;
  12
  13 var destDirectoryPath = '/test';
  14 var sourceDirectoryPath = '../../editing/pasteboard/resources';
  15
  16 // Actual files in the sourceDirectoryPath.
  17 var testFiles = [
  18     { path:'apple.gif' },
  19     { path:'mozilla.gif' },
  20     { path:'drop-file-svg.svg' },
  21     { path:'copy-backslash-euc.html' },
  22     { path:'test_directory', directory:true },
  23     { path:'test_directory/test.txt' }
  24 ];
  25
  26 // Note: for now we don't run moveTo test since drag-and-drop isolated
  27 // filesystem, which we use for source filesystem, is read-only.
  28 // FIXME: allow writing to PERSISTENT filesystem without quota error in
  29 // DumpRenderTree so that we can test TEMPORARY <-> PERSISTENT cross operation
  30 // checks.
  31 var tests = [
  32     testCopyFile,
  33     testCopyDirectory,
  34 ];
  35
  36 function log(text)
  37 {
  38     var console = document.getElementById('console');
  39     console.appendChild(document.createTextNode(text));
  40     console.appendChild(document.createElement('br'));
  41 }
  42
  43 function test(expect, actual)
  44 {
  45     log((expect == actual ? 'PASS' : 'FAIL') + ': "' + expect + '" == "' + actual + '"');
  46 }
  47
  48
  49 function errorCallback(msg)
  50 {
  51     return function(e) {
  52         console.log(e);
  53         log('ERROR:' + msg + ': ' + e.name);
  54         if (window.testRunner)
  55             testRunner.notifyDone();
  56     };
  57 }
  58
  59 function setupDestFileSystem(successCallback) {
  60     webkitRequestFileSystem(window.TEMPORARY, 1024, function (fs) {
  61         fs.root.getDirectory(
  62             destDirectoryPath,
  63             {create:true},
  64             function (entry) {
  65                 destTestDirectory = entry;
  66                 successCallback();
  67             },
  68             errorCallback('dest: createDirectory(' + destDirectoryPath + ')'));
  69     }, errorCallback('dest: requestFileSystem for PERSISTENT'));
  70 }
  71
  72 function runTests(index, successCallback) {
  73     if (index >= tests.length) {
  74         successCallback();
  75         return;
  76     }
  77     var next = function() { runTests(index + 1, successCallback); };
  78     resetDirectory(destTestDirectory, function() { tests[index](next); });
  79 }
  80
  81 function testCopyFile(successCallback) {
  82     testOnFile(0, 'copyTo', successCallback);
  83 }
  84
  85 function testCopyDirectory(successCallback) {
  86     testOnDirectory(0, 'copyTo', successCallback);
  87 }
  88
  89 function testOnFile(index, method, successCallback) {
  90     if (index >= testFiles.length) {
  91         successCallback();
  92         return;
  93     }
  94     var next = function() { testOnFile(index + 1, method, successCallback); };
  95     if (testFiles[index].directory) {
  96         next();
  97         return;
  98     }
  99     var file = testFiles[index];
 100     log('Testing ' + method + ' ' + file.path + ': ' + sourceTestDirectory.fullPath + ' => ' + destTestDirectory.fullPath);
 101     sourceTestDirectory.getFile(
 102         file.path, {create:false}, function(source) {
 103             source[method](destTestDirectory, '', function(dest) {
 104                 verifyFile(source, dest, next);
 105             }, errorCallback('testOnFile: ' + method + ':' + file.path));
 106         }, errorCallback('testOnFile: getFile:' + file.path));
 107 }
 108
 109 function testOnDirectory(index, method, successCallback) {
 110     if (index >= testFiles.length) {
 111         successCallback();
 112         return;
 113     }
 114     var next = function() { testOnFile(index + 1, method, successCallback); };
 115     if (!testFiles[index].directory) {
 116         next();
 117         return;
 118     }
 119     var file = testFiles[index];
 120     log('Testing ' + method + ' ' + file.path + ': ' + sourceTestDirectory.fullPath + ' => ' + destTestDirectory.fullPath);
 121     sourceTestDirectory.getDirectory(
 122         file.path, {create:false}, function(source) {
 123             source[method](destTestDirectory, '', function(dest) {
 124                 verifyFile(source, dest, next);
 125             }, errorCallback('testOnDirectory: ' + method + ':' + file.path));
 126         }, errorCallback('testOnDirectory: getDirectory:' + file.path));
 127 }
 128
 129 function verifyFile(source, dest, successCallback) {
 130     test(source.name, dest.name);
 131     source.getMetadata(function(sourceMetadata) {
 132         var expectedSize = sourceMetadata.size;
 133         dest.getMetadata(function(destMetadata) {
 134             test(expectedSize, destMetadata.size);
 135             successCallback();
 136         }, errorCallback('getMetadata:' + dest.fullPath));
 137     }, errorCallback('getMetadata:' + source.fullPath));
 138 }
 139
 140 function verifyDirectory(source, dest, successCallback) {
 141     getDirectoryEntries(source, function(sourceEntries) {
 142         getDirectoryEntries(dest, function(destEntries) {
 143             sourceEntries.sort();
 144             destEntries.sort();
 145             test(sourceEntries.length, destEntries.length);
 146             var verifyOne = function(index) {
 147                 verifyFile(sourceEntries[index], destEntries[index], function() {
 148                     if (index >= sourceEntries.length) {
 149                         successCallback();
 150                         return;
 151                     }
 152                     verifyOne(index + 1);
 153                 });
 154             };
 155             verifyOne(0);
 156         });
 157     });
 158 }
 159
 160 function getDirectoryEntries(entry, entriesCallback) {
 161     var allEntries = [];
 162     var addEntries = function(entries, continueCallback) {
 163         if (entries.length == 0) {
 164             entriesCallback(allEntries);
 165             return;
 166         }
 167         allEntries.concat(entries);
 168         if (entries.length != 0) continueCallback();
 169     };
 170     var entriesCallback = function(entries) {
 171         addEntries(entries, successCallback, function() {
 172             reader.readDirectory(entriesCallback);
 173         });
 174     };
 175     var reader = entry.createReader();
 176     reader.readDirectory(entriesCallback, errorCallback('readDirectory: ' + entry.fullPath));
 177 }
 178
 179 function cleanupDirectory(directory, successCallback) {
 180     directory.removeRecursively(
 181         successCallback,
 182         errorCallback('removeRecursively:' + directory.fullPath));
 183 }
 184
 185 function resetDirectory(directory, successCallback) {
 186     var fs = directory.filesystem;
 187     var path = directory.fullPath;
 188     cleanupDirectory(directory, function() {
 189         fs.root.getDirectory(path, {create:true},
 190                              function () {
 191                                 log(fs.name + ': reset ' + path);
 192                                 successCallback();
 193                              }, errorCallback('getDirectory(create):' + path));
 194     });
 195 }
 196
 197 function setupFiles(root, index, successCallback)
 198 {
 199     if (index >= testFiles.length) {
 200         successCallback();
 201         return;
 202     }
 203     var file = testFiles[index];
 204     var msg = 'create testFiles[' + index + ']: ' + file.path;
 205     var callback = function(entry) { setupFiles(root, index + 1, successCallback); };
 206     if (file.directory) {
 207         root.getDirectory(destDirectoryPath + '/' + file.path, {create:true}, callback, errorCallback(msg));
 208         return;
 209     }
 210
 211     root.getFile(file.path, {create:true}, function(entry) {
 212         entry.createWriter(function (writer) {
 213             writer.truncate(file.size);
 214             writer.onerror = errorCallback('truncate ' + entry.fullPath);
 215             writer.onwriteend = callback;
 216         }, errorCallback('create writer for ' + entry.fullPath));
 217     }, errorCallback(msg));
 218 }
 219
 220 function startTest(e) {
 221     e.stopPropagation(e);
 222     e.preventDefault();
 223
 224     log('Verifying contents of DataTransferItems...');
 225     var items = e.dataTransfer.items;
 226     test(1, items.length);
 227     test('file', items[0].kind);
 228
 229     var entry = items[0].webkitGetAsEntry();
 230     test(true, entry.isDirectory);
 231     sourceTestDirectory = entry;
 232     setupDestFileSystem(function() {
 233         log('Successfully setup test environment.');
 234         runTests(0, function() {
 235             log('Successfully ran ' + tests.length + ' tests.');
 236             cleanupDirectory(destTestDirectory, function() {
 237                 log('Cleanup done.');
 238                 if (window.testRunner)
 239                     testRunner.notifyDone();
 240             });
 241         });
 242     });
 243 }
 244
 245 var destination = document.getElementById('destination');
 246 destination.addEventListener('dragover', function(e) {
 247     e.stopPropagation();
 248     e.preventDefault();
 249 }, false);
 250 destination.addEventListener('drop', startTest, false);
 251
 252 if (window.testRunner) {
 253     testRunner.waitUntilDone();
 254     testRunner.dumpAsText();
 255
 256     eventSender.beginDragWithFiles([sourceDirectoryPath]);
 257     eventSender.leapForward(100);
 258     eventSender.mouseMoveTo(destination.offsetLeft + 10, destination.offsetTop + destination.offsetHeight / 2);
 259     eventSender.mouseUp();
 260 }
 261
 262 </script>
 263 </body>
 264 </html>