// Helper routine.
function toString(obj) {
if (obj == undefined) {
return "undefined";
} else if (typeof obj == 'object') {
if (obj.length != undefined) {
var stringArray = [];
for (var i = 0; i < obj.length; ++i)
stringArray.push(toString(obj[i]));
stringArray.sort();
return '[' + stringArray.join(',\n ') + ']';
} else if (obj.isDirectory || obj.isFile) {
return 'ENTRY {path:' + obj.fullPath + ' name:' + obj.name + (obj.isDirectory ? ' type:DIRECTORY' : ' type:FILE') + '}';
} else {
return obj + "";
}
} else
return obj + "";
}
// Creates a test environment for the given entries where entries is an array of {fullPath:String, isDirectory:boolean} object.
// When the world is created successfully, successCallback is called with an object that holds all the created entry objects.
function createTestEnvironment(fileSystem, entries, successCallback, errorCallback)
{
var Helper = function(fileSystem, entries, successCallback, errorCallback)
{
this.fileSystem = fileSystem;
this.entries = entries;
this.current = 0;
this.successCallback = successCallback;
this.errorCallback = errorCallback;
this.environment = {};
this.createSuccessCallback = function(entry, size)
{
if (entry.isFile && size > 0) {
entry.createWriter(bindCallback(this, function(writer) {
writer.truncate(size);
writer.onerror = bindCallback(this, this.createErrorCallback);
writer.onwriteend = bindCallback(this, function() {
this.environment[entry.fullPath] = entry;
this.environment[entry.fullPath + '.size'] = size;
this.createNextEntry();
});
}), bindCallback(this, this.createErrorCallback));
return;
}
this.environment[entry.fullPath] = entry;
this.environment[entry.fullPath + '.size'] = 0;
this.createNextEntry();
}
this.createErrorCallback = function(error, entry)
{
testFailed('Got unexpected error ' + error.name + ' while creating ' + toString(entry));
this.errorCallback(error);
}
this.createNextEntry = function()
{
if (this.current >= this.entries.length) {
this.successCallback(this.environment);
return;
}
var entry = this.entries[this.current++];
if (entry.isDirectory)
fileSystem.root.getDirectory(entry.fullPath, {create:true}, bindCallback(this, this.createSuccessCallback), bindCallback(this, this.createErrorCallback));
else
fileSystem.root.getFile(entry.fullPath, {create:true}, bindCallback(this, this.createSuccessCallback, entry.size), bindCallback(this, this.createErrorCallback));
};
};
if (!entries || !entries.length) {
successCallback({});
return;
}
var helper = new Helper(fileSystem, entries, successCallback, errorCallback);
helper.createNextEntry();
}
function verifyTestEnvironment(fileSystem, entries, successCallback, errorCallback)
{
var Helper = function(fileSystem, entries, successCallback, errorCallback)
{
this.fileSystem = fileSystem;
this.entries = entries;
this.current = 0;
this.successCallback = successCallback;
this.errorCallback = errorCallback;
this.expectedNonexistent = false;
this.verifySuccessCallback = function(entry)
{
if (this.expectedNonexistent) {
testFailed('Found unexpected entry ' + entry.fullPath);
this.errorCallback();
return;
}
testPassed('Verified entry: ' + toString(entry));
this.verifyNextEntry();
}
this.verifyErrorCallback = function(error, entry)
{
if (this.expectedNonexistent) {
testPassed('Verified entry does NOT exist: ' + entry.fullPath);
this.verifyNextEntry();
return;
}
if (error == 'NotFoundError')
testFailed('Not found: ' + entry.fullPath);
else
testFailed('Got unexpected error ' + error.name + ' for ' + entry.fullPath);
this.errorCallback(error);
}
this.verifyNextEntry = function()
{
if (this.current >= this.entries.length) {
this.successCallback();
return;
}
var entry = this.entries[this.current++];
this.expectedNonexistent = entry.nonexistent;
if (entry.isDirectory)
fileSystem.root.getDirectory(entry.fullPath, {}, bindCallback(this, this.verifySuccessCallback), bindCallback(this, this.verifyErrorCallback, entry));
else
fileSystem.root.getFile(entry.fullPath, {}, bindCallback(this, this.verifySuccessCallback), bindCallback(this, this.verifyErrorCallback, entry));
};
};
if (!entries || !entries.length) {
successCallback();
return;
}
var helper = new Helper(fileSystem, entries, successCallback, errorCallback);
helper.verifyNextEntry();
}
// testCase must have precondition, postcondition and test function field.
// (See resources/op-*.js for examples.)
function runOperationTest(fileSystem, testCase, successCallback, errorCallback)
{
var OperationTestHelper = function(fileSystem, testCase, successCallback, errorCallback)
{
this.fileSystem = fileSystem;
this.testCase = testCase;
this.successCallback = successCallback;
this.errorCallback = errorCallback;
this.stage = '';
this.environment = {};
this.currentTest = 0;
this.currentReader = null;
this.readEntries = [];
this.getSymbolString = function(symbol)
{
return 'this.environment["' + symbol + '"]';
};
this.testSuccessCallback = function()
{
if (!this.expectedError) {
testPassed('Succeeded: ' + this.stage);
this.runNextTest();
} else
testFailed('Unexpectedly succeeded while ' + this.stage);
};
this.entry = null;
this.testGetSuccessCallback = function(entry)
{
if (!this.expectedError) {
testPassed('Succeeded: ' + this.stage);
this.entry = entry;
shouldBe.apply(this, ['this.environment[this.entry.fullPath].fullPath', '"' + entry.fullPath + '"']);
shouldBe.apply(this, ['this.environment[this.entry.fullPath].isFile + ""', '"' + entry.isFile + '"']);
shouldBe.apply(this, ['this.environment[this.entry.fullPath].isDirectory + ""', '"' + entry.isDirectory + '"']);
this.runNextTest();
} else
testFailed('Unexpectedly succeeded while ' + this.stage);
};
this.testCreateSuccessCallback = function(entry)
{
if (!this.expectedError) {
testPassed('Succeeded: ' + this.stage);
this.environment[entry.fullPath] = entry;
this.runNextTest();
} else
testFailed('Unexpectedly succeeded while ' + this.stage);
};
this.testGetParentSuccessCallback = function(entry)
{
if (!this.expectedError) {
testPassed('Succeeded: ' + this.stage);
debug('Parent entry: ' + toString(entry));
this.runNextTest();
} else
testFailed('Unexpectedly succeeded while ' + this.stage);
};
this.testReadEntriesSuccessCallback = function(entries)
{
if (this.expectedError)
testFailed('Unexpectedly succeeded while ' + this.stage);
this.readEntries.push.apply(this.readEntries, entries);
if (entries.length) {
this.currentReader.readEntries(bindCallback(this, this.testReadEntriesSuccessCallback), bindCallback(this, this.testErrorCallback));
return;
}
testPassed('Succeeded: ' + this.stage);
debug('Entries: ' + toString(this.readEntries));
this.runNextTest();
};
this.testMetadataSuccessCallback = function(metadata, entry)
{
if (!this.expectedError) {
testPassed('Succeeded: ' + this.stage);
var symbol = entry + '.returned.modificationTime';
this.environment[symbol] = metadata.modificationTime;
var entryMetadataString = this.getSymbolString(symbol);
if (entry != '/') {
shouldBeGreaterThanOrEqual.apply(this, [entryMetadataString, 'this.roundedStartDate']);
}
if (metadata.size) {
this.environment[entry + '.returned.size'] = metadata.size;
var entrySizeString = this.getSymbolString(entry + '.returned.size');
var expectedSizeString = this.getSymbolString(entry + '.size');
shouldBe.apply(this, [expectedSizeString, entrySizeString]);
}
this.runNextTest();
} else
testFailed('Unexpectedly succeeded while ' + this.stage);
};
this.testErrorCallback = function(error)
{
if (this.expectedError) {
shouldBe.apply(this, ['this.expectedError + ""', '"' + error.name + '"']);
this.runNextTest();
} else {
testFailed('Got unexpected error ' + error.name + ' while ' + this.stage);
this.errorCallback(error);
}
};
// Operations ---------------------------------------------------
this.getFile = function(entry, path, flags, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".getFile("' + path + '")';
var successCallback = (flags && flags.create) ? this.testCreateSuccessCallback : this.testGetSuccessCallback;
this.environment[entry].getFile(path, flags, bindCallback(this, successCallback), bindCallback(this, this.testErrorCallback));
};
this.getDirectory = function(entry, path, flags, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".getDirectory("' + path + '")';
var successCallback = (flags && flags.create) ? this.testCreateSuccessCallback : this.testGetSuccessCallback;
this.environment[entry].getDirectory(path, flags, bindCallback(this, successCallback), bindCallback(this, this.testErrorCallback));
};
this.getParent = function(entry, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".getParent()';
this.environment[entry].getParent(bindCallback(this, this.testGetParentSuccessCallback), bindCallback(this, this.testErrorCallback));
};
this.getMetadata = function(entry, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".getMetadata()';
this.environment[entry].getMetadata(bindCallback(this, this.testMetadataSuccessCallback, entry), bindCallback(this, this.testErrorCallback));
};
this.remove = function(entry, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".remove()';
this.environment[entry].remove(bindCallback(this, this.testSuccessCallback), bindCallback(this, this.testErrorCallback));
};
this.removeRecursively = function(entry, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".removeRecursively()';
this.environment[entry].removeRecursively(bindCallback(this, this.testSuccessCallback), bindCallback(this, this.testErrorCallback));
};
this.readDirectory = function(entry, expectedError)
{
this.expectedError = expectedError;
this.readEntries = [];
this.stage = '"' + entry + '".createReader().readEntries()';
this.currentReader = this.environment[entry].createReader();
this.currentReader.readEntries(bindCallback(this, this.testReadEntriesSuccessCallback), bindCallback(this, this.testErrorCallback));
};
this.copy = function(entry, destinationParent, newName, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".copyTo("' + destinationParent + '", "' + newName + '")';
this.environment[entry].copyTo(this.environment[destinationParent], newName, bindCallback(this, this.testSuccessCallback), bindCallback(this, this.testErrorCallback));
};
this.move = function(entry, destinationParent, newName, expectedError)
{
this.expectedError = expectedError;
this.stage = '"' + entry + '".moveTo("' + destinationParent + '", "' + newName + '")';
this.environment[entry].moveTo(this.environment[destinationParent], newName, bindCallback(this, this.testSuccessCallback), bindCallback(this, this.testErrorCallback));
};
this.shouldBe = function(symbol1, symbol2)
{
shouldBe.apply(this, [this.getSymbolString(symbol1), this.getSymbolString(symbol2)]);
this.runNextTest();
};
this.shouldBeGreaterThanOrEqual = function(symbol1, symbol2)
{
shouldBeGreaterThanOrEqual.apply(this, [this.getSymbolString(symbol1), this.getSymbolString(symbol2)]);
this.runNextTest();
};
//---------------------------------------------------------------
this.start = function()
{
this.expectedError = '';
this.stage = 'resetting filesystem';
// Record rounded start date (current time minus 999 msec) here for the comparison. Entry.getMetadata() may return the last mod time in seconds accuracy while new Date() is milliseconds accuracy.
this.roundedStartDate = new Date((new Date()).getTime() - 999);
removeAllInDirectory(this.fileSystem.root, bindCallback(this, this.setUp), bindCallback(this, this.testErrorCallback));
};
this.setUp = function()
{
this.expectedError = '';
this.stage = 'setting up test precondition';
createTestEnvironment(this.fileSystem, this.testCase.precondition, bindCallback(this, this.runTests), bindCallback(this, this.testErrorCallback));
};
this.runNextTest = function()
{
if (this.currentTest >= this.testCase.tests.length) {
this.verify();
return;
}
this.testCase.tests[this.currentTest++](this);
};
this.runTests = function(environment)
{
this.environment = environment;
this.environment['/'] = this.fileSystem.root;
this.currentTest = 0;
this.runNextTest();
};
this.verify = function()
{
this.expectedError = '';
if (!this.testCase.postcondition) {
this.successCallback();
return;
}
this.stage = 'verifying test postcondition';
verifyTestEnvironment(this.fileSystem, this.testCase.postcondition, this.successCallback, bindCallback(this, this.testErrorCallback));
};
};
var helper = new OperationTestHelper(fileSystem, testCase, successCallback, errorCallback);
helper.start();
}
var currentTest = 0;
var fileSystem = null;
function runNextTest() {
if (currentTest >= testCases.length) {
debug('Finished running tests.');
finishJSTest();
return;
}
var testCase = testCases[currentTest++];
debug('* Running: ' + testCase.name);
runOperationTest(fileSystem, testCase, runNextTest, errorCallback);
}
function errorCallback(error) {
if (error && error.name)
testFailed('Got error ' + error.name);
finishJSTest();
}
function fileSystemCallback(fs)
{
fileSystem = fs;
runNextTest();
}
var jsTestIsAsync = true;
webkitRequestFileSystem(TEMPORARY, 100, fileSystemCallback, errorCallback);
Codebase Browser
chromium