exports.init = function() {
  eval(require('org.apache.cordova.test-framework.test').injectJasmineInterface(this, 'this'));

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 *
*/

function createFail(message, done) {
    return function() {
        console.log('[ERROR] ' + message);
        expect(true).toBe(false);
        done();
    };
}

function createMessageFail(label, done) {
    return function(message) {
        return function() {
            console.log('[ERROR] ' + label + ': ' + message);
            expect(true).toBe(false);
            done();
        };
    };
}

function createWin(message, done) {
    return function() {
        console.log('[ERROR: Unexpected success callback] ' + message);
        expect(false).toBe(true);
        done();
    };
}


describe('File API', function() {
    // Adding a Jasmine helper matcher, to report errors when comparing to FileError better.
    var fileErrorMap = {
        1: 'NOT_FOUND_ERR',
        2: 'SECURITY_ERR',
        3: 'ABORT_ERR',
        4: 'NOT_READABLE_ERR',
        5: 'ENCODING_ERR',
        6: 'NO_MODIFICATION_ALLOWED_ERR',
        7: 'INVALID_STATE_ERR',
        8: 'SYNTAX_ERR',
        9: 'INVALID_MODIFICATION_ERR',
        10:'QUOTA_EXCEEDED_ERR',
        11:'TYPE_MISMATCH_ERR',
        12:'PATH_EXISTS_ERR'
    };

    beforeEach(function() {
        addMatchers({
            toBeFileError: function(util, customEqualityTesters) {
                return {
                    compare: function(actual, code) {
                        var result = {};
                        result.pass = util.equals(actual.code, code, customEqualityTesters);
                        if (result.pass) {
                            result.message = "Expected " + actual + "not to be FileError with code " + fileErrorMap[code] + " (" + code + ")";
                        } else {
                            result.message = "Expected FileError with code " + fileErrorMap[actual.code] + " (" + actual.code + ") to be " + fileErrorMap[code] + "(" + code + ")";
                        }
                        return result;
                    }
                };
            },
            toCanonicallyMatch: function(util, customEqualityTesters) {
                return {
                    compare: function(actual, path) {
                        var result = {};
                        var a = path.split("/").join("").split("\\").join("");
                        var b = actual.split("/").join("").split("\\").join("");
                        result.pass = util.equals(a, b, customEqualityTesters);
                        if (result.pass) {
                            result.message = "Expected paths not to match : " + path;
                        } else {
                            result.message = "Expected paths to match : " + actual + " should be " + path;
                        }
                        return result;
                    }
                };
            }
        });
    });

    // HELPER FUNCTIONS

    // deletes specified file or directory
    var deleteEntry = function(entry, success, error) {
        error = error || success;
        if (entry.isDirectory === true) {
            entry.removeRecursively(success, error);
        } else {
            entry.remove(success, error);
        }
    };

    // deletes file, if it exists, then invokes callback
    var deleteFile = function(root, fileName, success, error) {
        error = error || success;
        root.getFile(fileName, null,
            // remove file system entry
            function(entry) {
                deleteEntry(entry, success, error);
            },
            // doesn't exist: OK
            success);
    };
    // deletes and re-creates the specified file
    var createFile = function(root, fileName, success, error) {
        deleteFile(root, fileName, function() {
            root.getFile(fileName, {create: true}, success, error);
        });
    };
    // deletes and re-creates the specified directory
    var createDirectory = function(root, dirName, success, error) {
        deleteFile(root, dirName, function() {
           root.getDirectory(dirName, {create: true}, success, error);
        });
    };

    describe('FileError object', function() {
        it("file.spec.1 should define FileError constants", function() {
            expect(FileError.NOT_FOUND_ERR).toBe(1);
            expect(FileError.SECURITY_ERR).toBe(2);
            expect(FileError.ABORT_ERR).toBe(3);
            expect(FileError.NOT_READABLE_ERR).toBe(4);
            expect(FileError.ENCODING_ERR).toBe(5);
            expect(FileError.NO_MODIFICATION_ALLOWED_ERR).toBe(6);
            expect(FileError.INVALID_STATE_ERR).toBe(7);
            expect(FileError.SYNTAX_ERR).toBe(8);
            expect(FileError.INVALID_MODIFICATION_ERR).toBe(9);
            expect(FileError.QUOTA_EXCEEDED_ERR).toBe(10);
            expect(FileError.TYPE_MISMATCH_ERR).toBe(11);
            expect(FileError.PATH_EXISTS_ERR).toBe(12);
        });
    });

    describe('LocalFileSystem', function() {

        it("file.spec.2 should define LocalFileSystem constants", function() {
            expect(LocalFileSystem.TEMPORARY).toBe(0);
            expect(LocalFileSystem.PERSISTENT).toBe(1);
        });

        describe('window.requestFileSystem', function() {
            it("file.spec.3 should be defined", function() {
                expect(window.requestFileSystem).toBeDefined();
            });

            it("file.spec.4 should be able to retrieve a PERSISTENT file system", function(done) {
                var fail = createFail('window.requestFileSystem', done);
                window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, function(fileSystem) {
                    expect(fileSystem).toBeDefined();
                    expect(fileSystem.name).toBeDefined();
                    expect(fileSystem.name).toBe("persistent");
                    expect(fileSystem.root).toBeDefined();
                    done();
                }, fail);
            });

            it("file.spec.5 should be able to retrieve a TEMPORARY file system", function(done) {
                var fail = createFail('window.requestFileSystem', done);

                // Request the file system
                window.requestFileSystem(LocalFileSystem.TEMPORARY, 0, function(fileSystem) {
                    expect(fileSystem).toBeDefined();
                    expect(fileSystem.name).toBeDefined();
                    expect(fileSystem.name).toBe("temporary");
                    expect(fileSystem.root).toBeDefined();
                    done();
                }, fail);
            });

            it("file.spec.6 should error if you request a file system that is too large", function(done) {
                var win = createWin('window.requestFileSystem', done);

                // Request the file system
                window.requestFileSystem(LocalFileSystem.TEMPORARY, 1000000000000000, win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.QUOTA_EXCEEDED_ERR);
                    done();
                });
            });

            it("file.spec.7 should error out if you request a file system that does not exist", function(done) {
                var win = createWin('window.requestFileSystem', done);

                // Request the file system
                window.requestFileSystem(-1, 0, win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.SYNTAX_ERR);
                    done();
                });
            });
        });

        describe('window.resolveLocalFileSystemURI', function() {
            it("file.spec.8 should be defined", function() {
                expect(window.resolveLocalFileSystemURI).toBeDefined();
            });

            it("file.spec.9 should resolve a valid file name", function(done) {
                var fileName = "resolve.file.uri",
                    fail = createFail('window.resolveLocalFileSystemURI', done);

                // create a new file entry
                window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                    createFile(fs.root, fileName, function(entry) {
                        // lookup file system entry
                        window.resolveLocalFileSystemURI(entry.toURL(), function(fileEntry) {
                            expect(fileEntry).toBeDefined();
                            expect(fileEntry.name).toCanonicallyMatch(fileName);

                            // cleanup
                            deleteEntry(fileEntry,done,done);
                        }, fail);
                    }, fail);
                });
            });

            it("file.spec.10 resolve valid file name with parameters", function(done) {
                var fileName = "resolve.file.uri.params",
                    fail = createFail('window.resolveLocalFileSystemURI', done);

                // create a new file entry
                window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                    createFile(fs.root, fileName, function(entry) {
                        // lookup file system entry
                        window.resolveLocalFileSystemURI(entry.toURL() + "?1234567890", function(fileEntry) {
                            expect(fileEntry).toBeDefined();
                            expect(fileEntry.name).toBe(fileName);

                            // cleanup
                            deleteEntry(fileEntry,done,done);
                        }, fail);
                    }, fail);
                });
            });
            it("file.spec.11 should error (NOT_FOUND_ERR) when resolving (non-existent) invalid file name", function(done) {
                var win = createWin('window.resolveLocalFileSystemURI', done);

                // lookup file system entry
                window.resolveLocalFileSystemURI("file:///this.is.not.a.valid.file.txt", win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                    done();
                });
            });
            it("file.spec.12 should error (ENCODING_ERR) when resolving invalid URI with leading /", function(done) {
                var win = createWin('window.resolveLocalFileSystemURI', done);

                // lookup file system entry
                window.resolveLocalFileSystemURI("/this.is.not.a.valid.url", win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.ENCODING_ERR);
                    done();
                });
            });
        });
    });

    describe('Metadata interface', function() {
        it("file.spec.13 should exist and have the right properties", function() {
            var metadata = new Metadata();
            expect(metadata).toBeDefined();
            expect(metadata.modificationTime).toBeDefined();
        });
    });

    describe('Flags interface', function() {
        it("file.spec.14 should exist and have the right properties", function() {
            var flags = new Flags(false, true);
            expect(flags).toBeDefined();
            expect(flags.create).toBeDefined();
            expect(flags.create).toBe(false);
            expect(flags.exclusive).toBeDefined();
            expect(flags.exclusive).toBe(true);
        });
    });

    describe('FileSystem interface', function() {
        it("file.spec.15 should have a root that is a DirectoryEntry", function(done) {
            var fail = createFail('FileSystem', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                window.resolveLocalFileSystemURI(fs.root.toURL(), function(entry) {
                    expect(entry).toBeDefined();
                    expect(entry.isFile).toBe(false);
                    expect(entry.isDirectory).toBe(true);
                    expect(entry.name).toBeDefined();
                    expect(entry.fullPath).toBeDefined();
                    expect(entry.getMetadata).toBeDefined();
                    expect(entry.moveTo).toBeDefined();
                    expect(entry.copyTo).toBeDefined();
                    expect(entry.toURL).toBeDefined();
                    expect(entry.remove).toBeDefined();
                    expect(entry.getParent).toBeDefined();
                    expect(entry.createReader).toBeDefined();
                    expect(entry.getFile).toBeDefined();
                    expect(entry.getDirectory).toBeDefined();
                    expect(entry.removeRecursively).toBeDefined();
                    done();
                }, fail);
            });
        });
    });

    describe('DirectoryEntry', function() {
        it("file.spec.16 getFile: get Entry for file that does not exist", function(done) {
            var fileName = "de.no.file",
                win = createWin('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                fs.root.getFile(fileName, {create:false}, win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                    done();
                });
            });
        });
        it("file.spec.17 getFile: create new file", function(done) {
            var fileName = "de.create.file",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // create:true, exclusive:false, file does not exist
                fs.root.getFile(fileName, {create: true}, function(entry) {
                    expect(entry).toBeDefined();
                    expect(entry.isFile).toBe(true);
                    expect(entry.isDirectory).toBe(false);
                    expect(entry.name).toCanonicallyMatch(fileName);
                    expect(entry.fullPath).toBe(filePath);
                    // cleanup
                    entry.remove(done, done);
                }, fail);
            });
        });
        it("file.spec.18 getFile: create new file (exclusive)", function(done) {
            var fileName = "de.create.exclusive.file",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // create:true, exclusive:true, file does not exist
                fs.root.getFile(fileName, {create: true, exclusive:true}, function(entry) {
                    expect(entry).toBeDefined();
                    expect(entry.isFile).toBe(true);
                    expect(entry.isDirectory).toBe(false);
                    expect(entry.name).toBe(fileName);
                    expect(entry.fullPath).toBe(filePath);
    
                    // cleanup
                    entry.remove(done, done);
                }, fail);
            });
        });
        it("file.spec.19 getFile: create file that already exists", function(done) {
            var fileName = "de.create.existing.file",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;

                // create file to kick off test
                fs.root.getFile(fileName, {create:true}, function(file) {
                    // Back to fs to try to get the new file
                    // create:true, exclusive:false, file exists
                    fs.root.getFile(fileName, {create:true}, function(entry) {
                        expect(entry).toBeDefined();
                        expect(entry.isFile).toBe(true);
                        expect(entry.isDirectory).toBe(false);
                        expect(entry.name).toCanonicallyMatch(fileName);
                        expect(entry.fullPath).toBe(filePath);
    
                        // cleanup
                        entry.remove(done, fail);
                    }, fail);
                },
                fail);
            });
        });
        it("file.spec.20 getFile: create file that already exists (exclusive)", function(done) {
            var fileName = "de.create.exclusive.existing.file",
                win = createWin('DirectoryEntry', done),
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create file to kick off test
                fs.root.getFile(fileName, {create:true}, function(file) {
                    // create:true, exclusive:true, file exists
                    fs.root.getFile(fileName, {create:true, exclusive:true}, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.PATH_EXISTS_ERR);

                        // cleanup
                        file.remove(done, fail);
                    });
                }, fail);
            });
        });
        it("file.spec.21 getFile: get Entry for existing file", function(done) {
            var fileName = "de.get.file",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // create file to kick off test
                fs.root.getFile(fileName, {create:true}, function(file) {
                    // create:false, exclusive:false, file exists
                    fs.root.getFile(fileName, {create:false}, function(entry) {
                    expect(entry).toBeDefined();
                    expect(entry.isFile).toBe(true);
                    expect(entry.isDirectory).toBe(false);
                    expect(entry.name).toCanonicallyMatch(fileName);
                    expect(entry.fullPath).toCanonicallyMatch(filePath);

                    entry.remove(done, fail); //clean up
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.22 DirectoryEntry.getFile: get FileEntry for invalid path", function(done) {
            var fileName = "de:invalid:path",
                win = createWin('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create:false, exclusive:false, invalid path
                fs.root.getFile(fileName, {create:false}, win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.ENCODING_ERR);
                    done();
                });
            });
        });
        it("file.spec.23 DirectoryEntry.getDirectory: get Entry for directory that does not exist", function(done) {
            var dirName = "de.no.dir",
                win = createWin('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create:false, exclusive:false, directory does not exist
                fs.root.getDirectory(dirName, {create:false}, win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                    done();
                });
            });
        });
        it("file.spec.24 DirectoryEntry.getDirectory: create new dir with space then resolveFileSystemURI", function(done) {
            var dirName = "de create dir",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + dirName;
                // create:true, exclusive:false, directory does not exist
                fs.root.getDirectory(dirName, {create: true}, function(dirEntry) {
                    var dirURI = dirEntry.toURL();
                    // now encode URI and try to resolve
                    window.resolveLocalFileSystemURI(dirURI, function(directory) {
                        expect(directory).toBeDefined();
                        expect(directory.isFile).toBe(false);
                        expect(directory.isDirectory).toBe(true);
                        expect(directory.name).toCanonicallyMatch(dirName);
                        expect(directory.fullPath).toCanonicallyMatch(dirPath);

                        // cleanup
                        directory.remove(done, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.25 DirectoryEntry.getDirectory: create new dir with space resolveFileSystemURI with encoded URI", function(done) {
            var dirName = "de create dir",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + dirName;
                // create:true, exclusive:false, directory does not exist
                fs.root.getDirectory(dirName, {create: true}, function(dirEntry) {
                    var dirURI = dirEntry.toURL();
                    // now encode URI and try to resolve
                    window.resolveLocalFileSystemURI(encodeURI(dirURI), function(directory) {
                        expect(directory).toBeDefined();
                        expect(directory.isFile).toBe(false);
                        expect(directory.isDirectory).toBe(true);
                        expect(directory.name).toCanonicallyMatch(dirName);
                        expect(directory.fullPath).toCanonicallyMatch(dirPath);
                        // cleanup
                        directory.remove(done, fail);
                    }, fail);
                }, fail);
            });
        });

        it("file.spec.26 DirectoryEntry.getDirectory: create new directory", function(done) {
            var dirName = "de.create.dir",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + dirName;
                // create:true, exclusive:false, directory does not exist
                fs.root.getDirectory(dirName, {create: true}, function(directory) {
                    expect(directory).toBeDefined();
                    expect(directory.isFile).toBe(false);
                    expect(directory.isDirectory).toBe(true);
                    expect(directory.name).toCanonicallyMatch(dirName);
                    expect(directory.fullPath).toCanonicallyMatch(dirPath);

                    // cleanup
                    directory.remove(done, fail);
                }, fail);
            });
        });

        it("file.spec.27 DirectoryEntry.getDirectory: create new directory (exclusive)", function(done) {
            var dirName = "de.create.exclusive.dir",
                fail = createFail('DirectoryEntry', done);
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + dirName;
                // create:true, exclusive:true, directory does not exist
                fs.root.getDirectory(dirName, {create: true, exclusive:true}, function(directory) {
                    expect(directory).toBeDefined();
                    expect(directory.isFile).toBe(false);
                    expect(directory.isDirectory).toBe(true);
                    expect(directory.name).toCanonicallyMatch(dirName);
                    expect(directory.fullPath).toCanonicallyMatch(dirPath);

                    // cleanup
                    directory.remove(done, fail);
                }, fail);
            });
        });
        it("file.spec.28 DirectoryEntry.getDirectory: create directory that already exists", function(done) {
            var dirName = "de.create.existing.dir",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + dirName;
                // create directory to kick off test
                fs.root.getDirectory(dirName, {create:true}, function(directory) {
                    // create:true, exclusive:false, directory exists
                    fs.root.getDirectory(dirName, {create:true}, function(directory) {
                        expect(directory).toBeDefined();
                        expect(directory.isFile).toBe(false);
                        expect(directory.isDirectory).toBe(true);
                        expect(directory.name).toCanonicallyMatch(dirName);
                        expect(directory.fullPath).toCanonicallyMatch(dirPath);

                        // cleanup
                        directory.remove(done, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.29 DirectoryEntry.getDirectory: create directory that already exists (exclusive)", function(done) {
            var dirName = "de.create.exclusive.existing.dir",
                win = createWin('DirectoryEntry', done),
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create directory to kick off test
                fs.root.getDirectory(dirName, {create:true}, function(directory) {
                    var existingDir = directory;
                    // create:true, exclusive:true, directory exists
                    fs.root.getDirectory(dirName, {create:true, exclusive:true}, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.PATH_EXISTS_ERR);

                        // cleanup
                        existingDir.remove(done, fail);
                    });
                }, fail);
            });
        });
        it("file.spec.30 DirectoryEntry.getDirectory: get Entry for existing directory", function(done) {
            var dirName = "de.get.dir",
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + dirName;
                // create directory to kick off test
                fs.root.getDirectory(dirName, {create:true}, function(directory) {
                    // create:false, exclusive:false, directory exists
                    fs.root.getDirectory(dirName, {create:false}, function(directory) {
                        expect(directory).toBeDefined();
                        expect(directory.isFile).toBe(false);
                        expect(directory.isDirectory).toBe(true);
                        expect(directory.name).toCanonicallyMatch(dirName);
                        expect(directory.fullPath).toCanonicallyMatch(dirPath);

                        // cleanup
                        directory.remove(done, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.31 DirectoryEntry.getDirectory: get DirectoryEntry for invalid path", function(done) {
            var dirName = "de:invalid:path",
                win = createWin('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create:false, exclusive:false, invalid path
                fs.root.getDirectory(dirName, {create:false}, win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.ENCODING_ERR);
                    done();
                });
            });
        });
        it("file.spec.32 DirectoryEntry.getDirectory: get DirectoryEntry for existing file", function(done) {
            var fileName = "de.existing.file",
                win = createWin('DirectoryEntry', done),
                fail = createFail('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create file to kick off test
                fs.root.getFile(fileName, {create:true}, function(file) {
                    var existingFile = file;
                    // create:false, exclusive:false, existing file
                    fs.root.getDirectory(fileName, {create:false}, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.TYPE_MISMATCH_ERR);

                        // cleanup
                        existingFile.remove(done, done);
                    });
                }, fail);
            });
        });
        it("file.spec.33 DirectoryEntry.getFile: get FileEntry for existing directory", function(done) {
            var dirName = "de.existing.dir",
                fail = createFail('DirectoryEntry', done),
                win = createWin('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create directory to kick off test
                fs.root.getDirectory(dirName, {create:true}, function(directory) {
                    var existingDir = directory;
                    // create:false, exclusive:false, existing directory
                    fs.root.getFile(dirName, {create:false}, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.TYPE_MISMATCH_ERR);

                        // cleanup
                        existingDir.remove(done, done);
                    });
                }, fail);
            });

        });
        it("file.spec.34 DirectoryEntry.removeRecursively on directory", function(done) {
            var dirName = "de.removeRecursively",
                subDirName = "dir",
                fail = createFail('DirectoryEntry', done),
                win = createWin('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new directory entry to kick off test
                fs.root.getDirectory(dirName, {create:true}, function(entry) {
                    // create a sub-directory within directory
                    entry.getDirectory(subDirName, {create: true}, function(directory) {
                        // delete directory
                        entry.removeRecursively(function() {
                            // test that removed directory no longer exists
                            fs.root.getDirectory(dirName, {create:false}, win, function(error) {
                                expect(error).toBeDefined();
                                expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                                done();
                            });
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.35 createReader: create reader on existing directory", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create reader for root directory
                var reader = fs.root.createReader();
                expect(reader).toBeDefined();
                expect(typeof reader.readEntries).toBe('function');
                done();
            });
        });
        it("file.spec.36 removeRecursively on root file system", function(done) {
            var win = createWin('DirectoryEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // remove root file system
                fs.root.removeRecursively(win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.NO_MODIFICATION_ALLOWED_ERR);
                    done();
                });
            });
        });
    });

    describe('DirectoryReader interface', function() {
        describe("readEntries", function() {
            it("file.spec.37 should read contents of existing directory", function(done) {
                var fail = createFail('DirectoryReader', done);

                window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                    // create reader for root directory
                    var reader = fs.root.createReader();
                    // read entries
                    reader.readEntries(function(entries) {
                        expect(entries).toBeDefined();
                        expect(entries instanceof Array).toBe(true);
                        done();
                    }, fail);
                });
            });
            it("file.spec.38 should read contents of directory that has been removed", function(done) {
                var dirName = "de.createReader.notfound",
                    fail = createFail('DirectoryReader', done),
                    win = createWin('DirectoryReader', done);

                window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                    // create a new directory entry to kick off test
                    fs.root.getDirectory(dirName, {create:true}, function(directory) {
                        // delete directory
                        directory.removeRecursively(function() {
                            // read entries
                            var reader = directory.createReader();
                            reader.readEntries(win, function(error) {
                                expect(error).toBeDefined();
                                expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                                fs.root.getDirectory(dirName, {create:false}, win, function(error) {
                                    expect(error).toBeDefined();
                                    expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                                    done();
                                });
                            });
                        }, fail);
                    }, fail);
                });
            });
        });
    });

    describe('File', function() {
        it("file.spec.39 constructor should be defined", function() {
            expect(File).toBeDefined();
            expect(typeof File).toBe('function');
        });
        it("file.spec.40 should be define File attributes", function() {
            var file = new File();
            expect(file.name).toBeDefined();
            expect(file.fullPath).toBeDefined();
            expect(file.type).toBeDefined();
            expect(file.lastModifiedDate).toBeDefined();
            expect(file.size).toBeDefined();
        });
    });

    describe('FileEntry', function() {
        it("file.spec.41 should be define FileEntry methods", function(done) {
            var fileName = "fe.methods",
                fail = createFail('FileEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry to kick off test
                fs.root.getFile(fileName, {create:true}, function(fileEntry) {
                    expect(fileEntry).toBeDefined();
                    expect(typeof fileEntry.createWriter).toBe('function');
                    expect(typeof fileEntry.file).toBe('function');

                    // cleanup
                    fileEntry.remove(done, fail);
                }, fail);
            });
        });
        it("file.spec.42 createWriter should return a FileWriter object", function(done) {
            var fileName = "fe.createWriter",
                fail = createFail('FileEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry to kick off test
                fs.root.getFile(fileName, {create:true}, function(fileEntry) {
                    var testFile = fileEntry;
                    fileEntry.createWriter(function(writer) {
                        expect(writer).toBeDefined();
                        expect(writer instanceof FileWriter).toBe(true);

                        // cleanup
                        testFile.remove(done, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.43 file should return a File object", function(done) {
            var fileName = "fe.file",
                fail = createFail('FileEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry to kick off test
                fs.root.getFile(fileName, {create:true}, function(fileEntry) {
                    var newFile = fileEntry;
                    fileEntry.file(function(file) {
                        expect(file).toBeDefined();
                        expect(file instanceof File).toBe(true);

                        // cleanup
                        newFile.remove(done, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.44 file: on File that has been removed", function(done) {
            var fileName = "fe.no.file",
                fail = createFail('FileEntry', done),
                win = createWin('FileEntry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry to kick off test
                fs.root.getFile(fileName, {create:true}, function(fileEntry) {
                    // delete file
                    fileEntry.remove(function() {
                        // create File object
                        fileEntry.file(win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                            done();
                        });
                    }, fail);
                }, fail);
            });
        });
    });
    describe('Entry', function() {
        it("file.spec.45 Entry object", function(done) {
            var fileName = "entry",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var fullPath = fs.root.fullPath + '/' + fileName;
                // create a new file entry
                createFile(fs.root, fileName, function(entry) {
                    expect(entry).toBeDefined();
                    expect(entry.isFile).toBe(true);
                    expect(entry.isDirectory).toBe(false);
                    expect(entry.name).toCanonicallyMatch(fileName);
                    expect(entry.fullPath).toCanonicallyMatch(fullPath);
                    expect(typeof entry.getMetadata).toBe('function');
                    expect(typeof entry.setMetadata).toBe('function');
                    expect(typeof entry.moveTo).toBe('function');
                    expect(typeof entry.copyTo).toBe('function');
                    expect(typeof entry.toURL).toBe('function');
                    expect(typeof entry.remove).toBe('function');
                    expect(typeof entry.getParent).toBe('function');
                    expect(typeof entry.createWriter).toBe('function');
                    expect(typeof entry.file).toBe('function');

                    // cleanup
                    entry.remove(done, done);
                }, fail);
            });
        });
        it("file.spec.46 Entry.getMetadata on file", function(done) {
            var fileName = "entry.metadata.file",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry
                createFile(fs.root, fileName, function(entry) {
                    entry.getMetadata(function(metadata) {
                        expect(metadata).toBeDefined();
                        expect(metadata.modificationTime instanceof Date).toBe(true);

                        // cleanup
                        deleteEntry(entry, done, done);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.47 Entry.getMetadata on directory", function(done) {
            var dirName = "entry.metadata.dir",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new directory entry
                createDirectory(fs.root, dirName, function(entry) {
                    entry.getMetadata(function(metadata) {
                        expect(metadata).toBeDefined();
                        expect(metadata.modificationTime instanceof Date).toBe(true);

                        // cleanup
                        deleteEntry(entry, done, done);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.48 Entry.getParent on file in root file system", function(done) {
            var fileName = "entry.parent.file",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var rootPath = fs.root.fullPath;
                // create a new file entry
                createFile(fs.root, fileName, function(entry) {
                    entry.getParent(function(parent) {
                        expect(parent).toBeDefined();
                        expect(parent.fullPath).toCanonicallyMatch(rootPath);

                        // cleanup
                        deleteEntry(entry, done, done);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.49 Entry.getParent on directory in root file system", function(done) {
            var dirName = "entry.parent.dir",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var rootPath = fs.root.fullPath;
                // create a new directory entry
                createDirectory(fs.root, dirName, function(entry) {
                    entry.getParent(function(parent) {
                        expect(parent).toBeDefined();
                        expect(parent.fullPath).toCanonicallyMatch(rootPath);

                        // cleanup
                        deleteEntry(entry, done, done);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.50 Entry.getParent on root file system", function(done) {
            var fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var rootPath = fs.root.fullPath;
                // create a new directory entry
                fs.root.getParent(function(parent) {
                    expect(parent).toBeDefined();
                    expect(parent.fullPath).toCanonicallyMatch(rootPath);
                    done();
                }, fail);
            });
        });
        it("file.spec.51 Entry.toURL on file", function(done) {
            var fileName = "entry.uri.file",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var rootPath = fs.root.fullPath;
                // create a new file entry
                createFile(fs.root, fileName, function(entry) {
                    var uri = entry.toURL();
                    expect(uri).toBeDefined();
                    expect(uri.indexOf(rootPath)).not.toBe(-1);

                    // cleanup
                    deleteEntry(entry, done, done);
                }, fail);
            });
        });
        it("file.spec.52 Entry.toURL on directory", function(done) {
            var dirName = "entry.uri.dir",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var rootPath = fs.root.fullPath;
                // create a new directory entry
                createDirectory(fs.root, dirName, function(entry) {
                    var uri = entry.toURL();
                    expect(uri).toBeDefined();
                    expect(uri.indexOf(rootPath)).not.toBe(-1);

                    // cleanup
                    deleteEntry(entry, done, done);
                }, fail);
            });
        });
        it("file.spec.53 Entry.remove on file", function(done) {
            var fileName = "entry.rm.file",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry
                createFile(fs.root, fileName, function(entry) {
                    expect(entry).toBeDefined();
                    entry.remove(function() {
                        fs.root.getFile(fileName, null, win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                            // cleanup
                            deleteEntry(entry, done, done);
                        });
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.54 remove on empty directory", function(done) {
            var dirName = "entry.rm.dir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new directory entry
                createDirectory(fs.root, dirName, function(entry) {
                    expect(entry).toBeDefined();
                    entry.remove(function() {
                        fs.root.getDirectory(dirName, null, win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                            // cleanup
                            deleteEntry(entry, done, done);
                        });
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.55 remove on non-empty directory", function(done) {
            var dirName = "entry.rm.dir.not.empty",
                fileName = "remove.txt",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var fullPath = fs.root.fullPath + '/' + dirName;
                // create a new directory entry
                createDirectory(fs.root, dirName, function(entry) {
                    // create a file within directory, then try to delete directory
                    entry.getFile(fileName, {create: true}, function(fileEntry) {
                        // delete directory
                        entry.remove(win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                            // verify that dir still exists
                            fs.root.getDirectory(dirName, null, function(entry) {
                                expect(entry).toBeDefined();
                                expect(entry.fullPath).toCanonicallyMatch(fullPath);
                                // cleanup
                                deleteEntry(entry, done, done);
                            }, fail);
                        });
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.56 remove on root file system", function(done) {
            var win = createWin('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // remove entry that doesn't exist
                fs.root.remove(win, function(error) {
                    expect(error).toBeDefined();
                    expect(error).toBeFileError(FileError.NO_MODIFICATION_ALLOWED_ERR);
                    done();
                });
            });
        });
        it("file.spec.57 copyTo: file", function(done) {
            var file1 = "entry.copy.file1",
                file2 = "entry.copy.file2",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var fullPath = fs.root.fullPath + '/' + file2;
                // create a new file entry to kick off test
                createFile(fs.root, file1, function(entry) {
                    // copy file1 to file2
                    entry.copyTo(fs.root, file2, function(entry) {
                        expect(entry).toBeDefined();
                        expect(entry.isFile).toBe(true);
                        expect(entry.isDirectory).toBe(false);
                        expect(entry.fullPath).toCanonicallyMatch(fullPath);
                        expect(entry.name).toCanonicallyMatch(file2);
                        fs.root.getFile(file2, {create:false}, function(entry2) {
                            // a bit redundant since copy returned this entry already
                            expect(entry2).toBeDefined();
                            expect(entry2.isFile).toBe(true);
                            expect(entry2.isDirectory).toBe(false);
                            expect(entry2.fullPath).toCanonicallyMatch(fullPath);
                            expect(entry2.name).toCanonicallyMatch(file2);

                            // cleanup
                            deleteEntry(entry, function() {
                                deleteEntry(entry2, done);
                            });
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.58 copyTo: file onto itself", function(done) {
            var file1 = "entry.copy.fos.file1",
                fail = createFail('Entry', done),
                win = createWin('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry to kick off test
                createFile(fs.root, file1, function(entry) {
                    // copy file1 onto itself
                    entry.copyTo(fs.root, null, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);

                        // cleanup
                        deleteEntry(entry, done, done);
                    });
                }, fail);
            });
        });
        it("file.spec.59 copyTo: directory", function(done) {
            var file1 = "file1",
                srcDir = "entry.copy.srcDir",
                dstDir = "entry.copy.dstDir",
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dstPath = fs.root.fullPath + '/' + dstDir,
                    filePath = dstPath + '/' + file1;
                // create a new directory entry to kick off test
                createDirectory(fs.root, srcDir, function(srcDirEntry) {
                    // create a file within new directory
                    srcDirEntry.getFile(file1, {create: true}, function(fileEntry) {
                        // copy srcDir to dstDir
                        srcDirEntry.copyTo(fs.root, dstDir, function(directory) {
                            expect(directory).toBeDefined();
                            expect(directory.isFile).toBe(false);
                            expect(directory.isDirectory).toBe(true);
                            expect(directory.fullPath).toCanonicallyMatch(dstPath);
                            expect(directory.name).toCanonicallyMatch(dstDir);

                            fs.root.getDirectory(dstDir, {create:false}, function(dstDirEntry) {
                                 expect(dstDirEntry).toBeDefined();
                                 expect(dstDirEntry.isFile).toBe(false);
                                 expect(dstDirEntry.isDirectory).toBe(true);
                                 expect(dstDirEntry.fullPath).toCanonicallyMatch(dstPath);
                                 expect(dstDirEntry.name).toCanonicallyMatch(dstDir);

                                 dstDirEntry.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.isFile).toBe(true);
                                    expect(fileEntry.isDirectory).toBe(false);
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);
                                    expect(fileEntry.name).toCanonicallyMatch(file1);

                                    // cleanup
                                    deleteEntry(srcDirEntry, function() {
                                        deleteEntry(dstDirEntry, done);
                                    });
                                 }, fail);
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.60 copyTo: directory to backup at same root directory", function(done) {
            var file1 = "file1",
                srcDir = "entry.copy.srcDirSame",
                dstDir = "entry.copy.srcDirSame-backup",
                failWith = createMessageFail('Entry copyTo: directory to backup at same root', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dstPath = fs.root.fullPath + '/' + dstDir,
                    filePath = dstPath + '/' + file1;
                // create a new directory entry to kick off test
                createDirectory(fs.root, srcDir, function(srcDirEntry) {
                    // create a file within new directory
                    srcDirEntry.getFile(file1, {create: true}, function(fileEntry) {
                        // copy srcDir to dstDir
                        srcDirEntry.copyTo(fs.root, dstDir, function(directory) {
                            expect(directory).toBeDefined();
                            expect(directory.isFile).toBe(false);
                            expect(directory.isDirectory).toBe(true);
                            expect(directory.fullPath).toCanonicallyMatch(dstPath);
                            expect(directory.name).toCanonicallyMatch(dstDir);

                            fs.root.getDirectory(dstDir, {create:false}, function(dstDirEntry) {
                                 expect(dstDirEntry).toBeDefined();
                                 expect(dstDirEntry.isFile).toBe(false);
                                 expect(dstDirEntry.isDirectory).toBe(true);
                                 expect(dstDirEntry.fullPath).toCanonicallyMatch(dstPath);
                                 expect(dstDirEntry.name).toCanonicallyMatch(dstDir);

                                 dstDirEntry.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.isFile).toBe(true);
                                    expect(fileEntry.isDirectory).toBe(false);
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);
                                    expect(fileEntry.name).toCanonicallyMatch(file1);

                                    // cleanup
                                    deleteEntry(srcDirEntry, function() {
                                        deleteEntry(dstDirEntry, done);
                                    });
                                 }, failWith("final getFile failed"));
                            }, failWith("final getDirectory failed"));
                        }, failWith("srcDirEntry.copyTo failed"));
                    }, failWith("initial getFile failed"));
                }, failWith("createDirectory failed"));
            });
        });
        it("file.spec.61 copyTo: directory onto itself", function(done) {
            var file1 = "file1",
                srcDir = "entry.copy.dos.srcDir",
                win = createWin('Entry', done),
                fail = createFail('Entry copyTo: directory onto itself', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir,
                    filePath = srcPath + '/' + file1;
                // create a new directory entry to kick off test
                createDirectory(fs.root, srcDir, function(directory) {
                    // create a file within new directory
                    directory.getFile(file1, {create: true}, function(fileEntry) {
                        // copy srcDir onto itself
                        directory.copyTo(fs.root, null, win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                            fs.root.getDirectory(srcDir, {create:false}, function(dirEntry) {
                                // returning confirms existence so just check fullPath entry
                                expect(dirEntry).toBeDefined();
                                expect(dirEntry.fullPath).toCanonicallyMatch(srcPath);
                                dirEntry.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);
                                    // cleanup
                                    deleteEntry(directory, done);
                                }, fail);
                            }, fail);
                        });
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.62 copyTo: directory into itself", function(done) {
            var srcDir = "entry.copy.dis.srcDir",
                dstDir = "entry.copy.dis.dstDir",
                fail = createFail('Entry', done),
                win = createWin('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir;
                // create a new directory entry to kick off test
                createDirectory(fs.root, srcDir, function(directory) {
                    // copy source directory into itself
                    directory.copyTo(directory, dstDir, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                        fs.root.getDirectory(srcDir, {create:false}, function(dirEntry) {
                            // returning confirms existence so just check fullPath entry
                            expect(dirEntry).toBeDefined();
                            expect(dirEntry.fullPath).toCanonicallyMatch(srcPath);

                            // cleanup
                            deleteEntry(directory, done);
                        }, fail);
                    });
                }, fail);
            });
        });
        it("file.spec.63 copyTo: directory that does not exist", function(done) {
            var file1 = "entry.copy.dnf.file1",
                dstDir = "entry.copy.dnf.dstDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + file1,
                    dstPath = fs.root.fullPath + '/' + dstDir;
                // create a new file entry to kick off test
                createFile(fs.root, file1, function(entry) {
                    // copy file to target directory that does not exist
                    var directory = new DirectoryEntry();
                    directory.fullPath = dstPath;
                    entry.copyTo(directory, null, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                        fs.root.getFile(file1, {create: false}, function(fileEntry) {
                            expect(fileEntry).toBeDefined();
                            expect(fileEntry.fullPath).toCanonicallyMatch(filePath);

                            // cleanup
                            deleteEntry(entry, done);
                        }, fail);
                    });
                }, fail);
            });
        });
        it("file.spec.64 copyTo: invalid target name", function(done) {
            var file1 = "entry.copy.itn.file1",
                file2 = "bad:file:name",
                fail = createFail('Entry', done),
                win = createWin('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + file1;
                // create a new file entry
                createFile(fs.root, file1, function(entry) {
                    // copy file1 to file2
                    entry.copyTo(fs.root, file2, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.ENCODING_ERR);
                        // cleanup
                        deleteEntry(entry, done);
                    });
                }, fail);
            });
        });
        it("file.spec.65 moveTo: file to same parent", function(done) {
            var file1 = "entry.move.fsp.file1",
                file2 = "entry.move.fsp.file2",
                fail = createFail('Entry', done),
                win = createWin('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + file1,
                    dstPath = fs.root.fullPath + '/' + file2;
                // create a new file entry to kick off test
                createFile(fs.root, file1, function(firstEntry) {
                    // move file1 to file2
                    firstEntry.moveTo(fs.root, file2, function(secondEntry) {
                        expect(secondEntry).toBeDefined();
                        expect(secondEntry.isFile).toBe(true);
                        expect(secondEntry.isDirectory).toBe(false);
                        expect(secondEntry.fullPath).toCanonicallyMatch(dstPath);
                        expect(secondEntry.name).toCanonicallyMatch(file2);

                        fs.root.getFile(file2, {create:false}, function(fileEntry) {
                            expect(fileEntry).toBeDefined();
                            expect(fileEntry.fullPath).toCanonicallyMatch(dstPath);

                            fs.root.getFile(file1, {create:false}, win, function(error) {
                                expect(error).toBeDefined();
                                expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                                // cleanup
                                deleteEntry(firstEntry, function() {
                                    deleteEntry(secondEntry, done);
                                });
                            });
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.66 moveTo: file to new parent", function(done) {
            var file1 = "entry.move.fnp.file1",
                dir = "entry.move.fnp.dir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dstPath = fs.root.fullPath + '/' + dir + '/' + file1;
                // ensure destination directory is cleaned up first
                deleteFile(fs.root, dir, function() {
                    // create a new file entry to kick off test
                    createFile(fs.root, file1, function(srcEntry) {
                        // move file1 to new directory
                        // create a parent directory to move file to
                        fs.root.getDirectory(dir, {create: true}, function(directory) {
                            // move the file
                            srcEntry.moveTo(directory, null, function(entry) {
                                expect(entry).toBeDefined();
                                expect(entry.isFile).toBe(true);
                                expect(entry.isDirectory).toBe(false);
                                expect(entry.fullPath).toCanonicallyMatch(dstPath);
                                expect(entry.name).toCanonicallyMatch(file1);
                                // test the moved file exists
                                directory.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(dstPath);
                                    // test that the file has moved
                                    fs.root.getFile(file1, {create:false}, win, function(error) {
                                        expect(error).toBeDefined();
                                        expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                                        // cleanup
                                        deleteEntry(srcEntry, function() {
                                            deleteEntry(directory, done);
                                        });
                                    });
                                }, fail);
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.67 moveTo: directory to same parent", function(done) {
            var file1 = "file1",
                srcDir = "entry.move.dsp.srcDir",
                dstDir = "entry.move.dsp.dstDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir,
                    dstPath = fs.root.fullPath + '/' + dstDir,
                    filePath = dstPath + '/' + file1;
                // ensure destination directory is cleaned up before test
                deleteFile(fs.root, dstDir, function() {
                    // create a new directory entry to kick off test
                    createDirectory(fs.root, srcDir, function(srcDirectory) {
                        // create a file within directory
                        srcDirectory.getFile(file1, {create: true}, function(fileEntry) {
                            // move srcDir to dstDir
                            srcDirectory.moveTo(fs.root, dstDir, function(dstDirectory) {
                                expect(dstDirectory).toBeDefined();
                                expect(dstDirectory.isFile).toBe(false);
                                expect(dstDirectory.isDirectory).toBe(true);
                                expect(dstDirectory.fullPath).toCanonicallyMatch(dstPath);
                                expect(dstDirectory.name).toCanonicallyMatch(dstDir);
                                // test that moved file exists in destination dir
                                dstDirectory.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);
                                    // check that the moved file no longer exists in original dir
                                    fs.root.getFile(file1, {create:false}, win, function(error) {
                                        expect(error).toBeDefined();
                                        expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                                        // cleanup
                                        deleteEntry(srcDirectory, function() {
                                            deleteEntry(dstDirectory, done);
                                        });
                                    });
                                }, fail);
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.68 moveTo: directory to same parent with same name", function(done) {
            var file1 = "file1",
                srcDir = "entry.move.dsp.srcDir",
                dstDir = "entry.move.dsp.srcDir-backup",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir,
                    dstPath = fs.root.fullPath + '/' + dstDir,
                    filePath = dstPath + '/' + file1;
                // ensure destination directory is cleaned up before test
                deleteFile(fs.root, dstDir, function() {
                    // create a new directory entry to kick off test
                    createDirectory(fs.root, srcDir, function(srcDirectory) {
                        // create a file within directory
                        srcDirectory.getFile(file1, {create: true}, function(fileEntry) {
                            // move srcDir to dstDir
                            srcDirectory.moveTo(fs.root, dstDir, function(dstDirectory) {
                                expect(dstDirectory).toBeDefined();
                                expect(dstDirectory.isFile).toBe(false);
                                expect(dstDirectory.isDirectory).toBe(true);
                                expect(dstDirectory.fullPath).toCanonicallyMatch(dstPath);
                                expect(dstDirectory.name).toCanonicallyMatch(dstDir);
                                // check that moved file exists in destination dir
                                dstDirectory.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);
                                    // check that the moved file no longer exists in original dir
                                    fs.root.getFile(file1, {create:false}, win, function(error) {
                                        expect(error).toBeDefined();
                                        expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                                        // cleanup
                                        deleteEntry(srcDirectory, function() {
                                            deleteEntry(dstDirectory, done);
                                        });
                                    });
                                }, fail);
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.69 moveTo: directory to new parent", function(done) {
            var file1 = "file1",
                srcDir = "entry.move.dnp.srcDir",
                dstDir = "entry.move.dnp.dstDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir,
                    dstPath = fs.root.fullPath + '/' + dstDir;
                    filePath = dstPath + '/' + file1;
                // ensure destination directory is cleaned up before test
                deleteFile(fs.root, dstDir, function() {
                    // create a new directory entry to kick off test
                    createDirectory(fs.root, srcDir, function(srcDirectory) {
                        // create a file within directory
                        srcDirectory.getFile(file1, {create: true}, function(fileEntry) {
                            // move srcDir to dstDir
                            srcDirectory.moveTo(fs.root, dstDir, function(dstDirectory) {
                                expect(dstDirectory).toBeDefined();
                                expect(dstDirectory.isFile).toBe(false);
                                expect(dstDirectory.isDirectory).toBe(true);
                                expect(dstDirectory.fullPath).toCanonicallyMatch(dstPath);
                                expect(dstDirectory.name).toCanonicallyMatch(dstDir);
                                // test that moved file exists in destination dir
                                dstDirectory.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);
                                    // test that the moved file no longer exists in original dir
                                    fs.root.getFile(file1, {create:false}, win, function(error) {
                                        expect(error).toBeDefined();
                                        expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                                        // cleanup
                                        deleteEntry(srcDirectory, function() {
                                            deleteEntry(dstDirectory, done);
                                        });
                                    });
                                }, fail);
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.70 moveTo: directory onto itself", function(done) {
            var file1 = "file1",
                srcDir = "entry.move.dos.srcDir",
                fail = createFail('Entry', done),
                win = createWin('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir,
                    filePath = srcPath + '/' + file1;
                // create a new directory entry to kick off test
                createDirectory(fs.root, srcDir, function(directory) {
                    // create a file within new directory
                    directory.getFile(file1, {create: true}, function(fileEntry) {
                        // move srcDir onto itself
                        directory.moveTo(fs.root, null, win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                            // test that original dir still exists
                            fs.root.getDirectory(srcDir, {create:false}, function(dirEntry) {
                                // returning confirms existence so just check fullPath entry
                                expect(dirEntry).toBeDefined();
                                expect(dirEntry.fullPath).toCanonicallyMatch(srcPath);
                                dirEntry.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);

                                    // cleanup
                                    deleteEntry(directory, done);
                                }, fail);
                            }, fail);
                        });
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.71 moveTo: directory into itself", function(done) {
            var srcDir = "entry.move.dis.srcDir",
                dstDir = "entry.move.dis.dstDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir;
                // create a new directory entry to kick off test
                createDirectory(fs.root, srcDir, function(directory) {
                    // move source directory into itself
                    directory.moveTo(directory, dstDir, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                        // make sure original directory still exists
                        fs.root.getDirectory(srcDir, {create:false}, function(entry) {
                            expect(entry).toBeDefined();
                            expect(entry.fullPath).toCanonicallyMatch(srcPath);

                            // cleanup
                            deleteEntry(directory, done);
                        }, fail);
                    });
                }, fail);
            });
        });
        it("file.spec.72 moveTo: file onto itself", function(done) {
            var file1 = "entry.move.fos.file1",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + file1;
                // create a new file entry to kick off test
                createFile(fs.root, file1, function(entry) {
                    // move file1 onto itself
                    entry.moveTo(fs.root, null, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);

                        //test that original file still exists
                        fs.root.getFile(file1, {create:false}, function(fileEntry) {
                            expect(fileEntry).toBeDefined();
                            expect(fileEntry.fullPath).toCanonicallyMatch(filePath);

                            // cleanup
                            deleteEntry(entry, done);
                        }, fail);
                    });
                }, fail);
            });
        });
        it("file.spec.73 moveTo: file onto existing directory", function(done) {
            var file1 = "entry.move.fod.file1",
                dstDir = "entry.move.fod.dstDir",
                subDir = "subDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + dstDir + '/' + subDir,
                    filePath = fs.root.fullPath + '/' + file1;
                // ensure destination directory is cleaned up before it
                deleteFile(fs.root, dstDir, function() {
                    // create a new file entry to kick off it
                    createFile(fs.root, file1, function(entry) {
                        // create top level directory
                        fs.root.getDirectory(dstDir, {create: true}, function(directory) {
                            // create sub-directory
                            directory.getDirectory(subDir, {create: true}, function(subdirectory) {
                                // move file1 onto sub-directory
                                entry.moveTo(directory, subDir, win, function(error) {
                                    expect(error).toBeDefined();
                                    expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                                    // check that original dir still exists
                                    directory.getDirectory(subDir, {create:false}, function(dirEntry) {
                                        expect(dirEntry).toBeDefined();
                                        expect(dirEntry.fullPath).toCanonicallyMatch(dirPath);
                                        // check that original file still exists
                                        fs.root.getFile(file1, {create:false}, function(fileEntry) {
                                            expect(fileEntry).toBeDefined();
                                            expect(fileEntry.fullPath).toCanonicallyMatch(filePath);

                                            // cleanup
                                            deleteEntry(entry, function() {
                                                deleteEntry(directory, done);
                                            });
                                        }, fail);
                                    }, fail);
                                });
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.74 moveTo: directory onto existing file", function(done) {
            var file1 = "entry.move.dof.file1",
                srcDir = "entry.move.dof.srcDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + srcDir,
                    filePath = fs.root.fullPath + '/' + file1;
                // create a new directory entry to kick off test
                createDirectory(fs.root, srcDir, function(entry) {
                    // create file
                    fs.root.getFile(file1, {create: true}, function(fileEntry) {
                        // move directory onto file
                        entry.moveTo(fs.root, file1, win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                            // test that original directory exists
                            fs.root.getDirectory(srcDir, {create:false}, function(dirEntry) {
                                // returning confirms existence so just check fullPath entry
                                expect(dirEntry).toBeDefined();
                                expect(dirEntry.fullPath).toCanonicallyMatch(dirPath);
                                // test that original file exists
                                fs.root.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);

                                    // cleanup
                                    deleteEntry(fileEntry, function() {
                                        deleteEntry(entry, done);
                                    });
                                }, fail);
                            }, fail);
                        });
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.75 copyTo: directory onto existing file", function(done) {
            var file1 = "entry.copy.dof.file1",
                srcDir = "entry.copy.dof.srcDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var dirPath = fs.root.fullPath + '/' + srcDir,
                    filePath = fs.root.fullPath + '/' + file1;
                // create a new directory entry to kick off it
                createDirectory(fs.root, srcDir, function(entry) {
                    // create file
                    fs.root.getFile(file1, {create: true}, function(fileEntry) {
                        // move directory onto file
                        entry.copyTo(fs.root, file1, win, function(error) {
                            expect(error).toBeDefined();
                            expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);
                            //check that original dir still exists
                            fs.root.getDirectory(srcDir, {create:false}, function(dirEntry) {
                                // returning confirms existence so just check fullPath entry
                                expect(dirEntry).toBeDefined();
                                expect(dirEntry.fullPath).toCanonicallyMatch(dirPath);
                                // it that original file still exists
                                fs.root.getFile(file1, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(filePath);

                                    // cleanup
                                    deleteEntry(fileEntry, function() {
                                        deleteEntry(dirEntry, done);
                                    });
                                }, fail);
                            }, fail);
                        });
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.76 moveTo: directory onto directory that is not empty", function(done) {
            var srcDir = "entry.move.dod.srcDir",
                dstDir = "entry.move.dod.dstDir",
                subDir = "subDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir,
                    dstPath = fs.root.fullPath + '/' + dstDir + '/' + subDir;
                // ensure destination directory is cleaned up before it
                deleteFile(fs.root, dstDir, function() {
                    // create a new file entry to kick off it
                    createDirectory(fs.root, srcDir, function(entry) {
                        // create top level directory
                        fs.root.getDirectory(dstDir, {create: true}, function(directory) {
                            // create sub-directory
                            directory.getDirectory(subDir, {create: true}, function(subDirectory) {
                                // move srcDir onto dstDir (not empty)
                                entry.moveTo(fs.root, dstDir, win, function(error) {
                                    expect(error).toBeDefined();
                                    expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR);

                                    // test that destination directory still exists
                                    directory.getDirectory(subDir, {create:false}, function(dirEntry) {
                                        // returning confirms existence so just check fullPath entry
                                        expect(dirEntry).toBeDefined();
                                        expect(dirEntry.fullPath).toCanonicallyMatch(dstPath);
                                        // test that source directory exists
                                        fs.root.getDirectory(srcDir,{create:false}, function(srcEntry) {
                                            expect(srcEntry).toBeDefined();
                                            expect(srcEntry.fullPath).toCanonicallyMatch(srcPath);
                                            // cleanup
                                            deleteEntry(entry, function() {
                                                deleteEntry(directory, done);
                                            });
                                        }, fail);
                                    }, fail);
                                });
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.77 moveTo: file replace existing file", function(done) {
            var file1 = "entry.move.frf.file1",
                file2 = "entry.move.frf.file2",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var file1Path = fs.root.fullPath + '/' + file1,
                    file2Path = fs.root.fullPath + '/' + file2;
                // create a new directory entry to kick off it
                createFile(fs.root, file1, function(entry) {
                    // create file
                    fs.root.getFile(file2, {create: true}, function(fileEntry) {
                        // replace file2 with file1
                        entry.moveTo(fs.root, file2, function(entry) {
                            expect(entry).toBeDefined();
                            expect(entry.isFile).toBe(true);
                            expect(entry.isDirectory).toBe(false);
                            expect(entry.fullPath).toCanonicallyMatch(file2Path);
                            expect(entry.name).toCanonicallyMatch(file2);

                            // test that old file does not exists
                            fs.root.getFile(file1, {create:false}, win, function(error) {
                                expect(error).toBeDefined();
                                expect(error).toBeFileError(FileError.NOT_FOUND_ERR);
                                // test that new file exists
                                fs.root.getFile(file2, {create:false}, function(fileEntry) {
                                    expect(fileEntry).toBeDefined();
                                    expect(fileEntry.fullPath).toCanonicallyMatch(file2Path);

                                    // cleanup
                                    deleteEntry(entry, function() {
                                        deleteEntry(fileEntry, done);
                                    });
                                }, fail);
                            });
                        }, fail);
                    },fail);
                }, fail);
            });
        });
        it("file.spec.78 moveTo: directory replace empty directory", function(done) {
            var file1 = "file1",
                srcDir = "entry.move.drd.srcDir",
                dstDir = "entry.move.drd.dstDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var srcPath = fs.root.fullPath + '/' + srcDir,
                    dstPath = fs.root.fullPath + '/' + dstDir,
                    filePath = dstPath + '/' + file1;
                // ensure destination directory is cleaned up before test
                deleteFile(fs.root, dstDir, function() {
                    // create a new directory entry to kick off test
                    createDirectory(fs.root, srcDir, function(srcDirectoryEntry) {
                        // create a file within source directory
                        srcDirectoryEntry.getFile(file1, {create: true}, function(fileEntry) {
                            // create destination directory
                            fs.root.getDirectory(dstDir, {create: true}, function(dstDirectoryEntry) {
                                // move srcDir to dstDir
                                srcDirectoryEntry.moveTo(fs.root, dstDir, function(directory) {
                                    expect(directory).toBeDefined();
                                    expect(directory.isFile).toBe(false);
                                    expect(directory.isDirectory).toBe(true);
                                    expect(directory.fullPath).toCanonicallyMatch(dstPath);
                                    expect(directory.name).toCanonicallyMatch(dstDir);
                                    // check that old directory contents have been moved
                                    directory.getFile(file1, {create:false}, function(fileEntry) {
                                        expect(fileEntry).toBeDefined();
                                        expect(fileEntry.fullPath).toCanonicallyMatch(filePath);

                                        // check that old directory no longer exists
                                        fs.root.getDirectory(srcDir, {create:false}, win, function(error) {
                                            expect(error).toBeDefined();
                                            expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                                            // cleanup
                                            deleteEntry(srcDirectoryEntry, function() {
                                                deleteEntry(dstDirectoryEntry, done);
                                            });
                                        });
                                    }, fail);
                                }, fail);
                            }, fail);
                        }, fail);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.79 moveTo: directory that does not exist", function(done) {
            var file1 = "entry.move.dnf.file1",
                dstDir = "entry.move.dnf.dstDir",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + file1,
                    dstPath = fs.root.fullPath + '/' + dstDir;
                // create a new file entry to kick off test
                createFile(fs.root, file1, function(entry) {
                    // move file to directory that does not exist
                    directory = new DirectoryEntry();
                    directory.fullPath = dstPath;
                    entry.moveTo(directory, null, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.NOT_FOUND_ERR);

                        // cleanup
                        deleteEntry(entry, done);
                    });
                }, fail);
            });
        });
        it("file.spec.80 moveTo: invalid target name", function(done) {
            var file1 = "entry.move.itn.file1",
                file2 = "bad:file:name",
                win = createWin('Entry', done),
                fail = createFail('Entry', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // create a new file entry to kick off it
                createFile(fs.root, file1, function(entry) {
                    // move file1 to file2
                    entry.moveTo(fs.root, file2, win, function(error) {
                        expect(error).toBeDefined();
                        expect(error).toBeFileError(FileError.ENCODING_ERR);

                        // cleanup
                        deleteEntry(entry, done);
                    });
                }, fail);
            });
        });
    });

    describe('FileReader', function() {
        it("file.spec.81 should have correct methods", function() {
            var reader = new FileReader();
            expect(reader).toBeDefined();
            expect(typeof reader.readAsBinaryString).toBe('function');
            expect(typeof reader.readAsDataURL).toBe('function');
            expect(typeof reader.readAsText).toBe('function');
            expect(typeof reader.readAsArrayBuffer).toBe('function');
            expect(typeof reader.abort).toBe('function');
        });
    });

    describe('read method', function(){
        it("file.spec.82 should error out on non-existent file", function(done) {
            var verifier = function(evt) {
                expect(evt).toBeDefined();
                expect(evt.target.error).toBeFileError(FileError.NOT_FOUND_ERR);
                done();
            };
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var reader = new FileReader();
                var myFile = new File();
                reader.onerror = verifier;
                myFile.fullPath = fs.root.fullPath + '/' + "doesnotexist.err";
                reader.readAsText(myFile);
            });
        });
        it("file.spec.83 should be able to read native blob objects", function(done) {
            // Skip test if blobs are not supported (e.g.: Android 2.3).
            if (typeof window.Blob == 'undefined' || typeof window.Uint8Array == 'undefined') {
                done();
            }
            var contents = 'asdf';
            var uint8Array = new Uint8Array(contents.length);
            for (var i = 0; i < contents.length; ++i) {
              uint8Array[i] = contents.charCodeAt(i);
            }
            var Builder = window.BlobBuilder || window.WebKitBlobBuilder;
            var blob;
            if (Builder) {
                var builder = new Builder();
                builder.append(uint8Array.buffer);
                builder.append(contents);
                blob = builder.getBlob("text/plain");
            } else {
                try {
                    // iOS 6 does not support Views, so pass in the buffer.
                    blob = new Blob([uint8Array.buffer, contents]);
                } catch (e) {
                    // Skip the test if we can't create a blob (e.g.: iOS 5).
                    if (e instanceof TypeError) {
                        return;
                    }
                    throw e;
                }
            }
            var verifier = function(evt) {
                expect(evt).toBeDefined();
                expect(evt.target.result).toBe('asdfasdf');
                done();
            };
            var reader = new FileReader();
            reader.onloadend = verifier;
            reader.readAsText(blob);
        });

        function writeDummyFile(root, writeBinary, callback, done) {
            var fileName = "dummy.txt",
                fileEntry = null,
                writerFail = createFail('createWriter', done),
                getFileFail = createFail('getFile', done),
                fileFail = createFail('file', done),
                fileData = '\u20AC\xEB - There is an exception to every rule.  Except this one.',
                fileDataAsBinaryString = '\xe2\x82\xac\xc3\xab - There is an exception to every rule.  Except this one.',
                // writes file and reads it back in
                writeFile = function(writer) {
                    writer.onwriteend = function() {
                        fileEntry.file(function(f) {
                            callback(fileEntry, f, fileData, fileDataAsBinaryString);
                        }, fileFail);
                    };
                    writer.write(fileData);
                };
            fileData += writeBinary ? 'bin:\x01\x00' : '';
            fileDataAsBinaryString += writeBinary ? 'bin:\x01\x00' : '';
            // create a file, write to it, and read it in again
            root.getFile(fileName, {create: true}, function(fe) {
                fileEntry = fe;
                fileEntry.createWriter(writeFile, writerFail);
            }, getFileFail);
        }

        function runReaderTest(root, funcName, writeBinary, verifierFunc, done, sliceStart, sliceEnd) {
            writeDummyFile(root, writeBinary, function(fileEntry, file, fileData, fileDataAsBinaryString) {
                var readWin = function(evt) {
                    expect(evt).toBeDefined();
                    verifierFunc(evt, fileData, fileDataAsBinaryString);
                };

                var reader = new FileReader();
                var readFail = createFail(funcName, done);
                reader.onload = readWin;
                reader.onerror = readFail;
                if (sliceEnd !== undefined) {
                    file = file.slice(sliceStart, sliceEnd);
                } else if (sliceStart !== undefined) {
                    file = file.slice(sliceStart);
                }
                reader[funcName](file);
            }, done);
        }

        function arrayBufferEqualsString(ab, str) {
            var buf = new Uint8Array(ab);
            var match = buf.length == str.length;

            for (var i = 0; match && i < buf.length; i++) {
                match = buf[i] == str.charCodeAt(i);
            }
            return match;
        }

        it("file.spec.84 should read file properly, readAsText", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsText', false, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result).toBe(fileData);
                    done();
                }, done);
            });
        });
        it("file.spec.85 should read file properly, Data URI", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root,'readAsDataURL', true, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result.substr(0,23)).toBe("data:text/plain;base64,");
                    // TODO: See if this line is running in existing mobile spec tests
                    // It fails with INVALID_CHARACTER_ERR on Safari 6.1
                    expect(evt.target.result.slice(23)).toBe(atob(fileData));
                    done();
                }, done);
            });
        });
        it("file.spec.86 should read file properly, readAsBinaryString", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root,'readAsBinaryString', true, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result).toBe(fileDataAsBinaryString);
                    done();
                }, done);
            });
        });
        it("file.spec.87 should read file properly, readAsArrayBuffer", function(done) {
            // Skip test if ArrayBuffers are not supported (e.g.: Android 2.3).
            if (typeof window.ArrayBuffer == 'undefined') {
                done();
            }
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsArrayBuffer', true, function(evt, fileData, fileDataAsBinaryString) {
                    expect(arrayBufferEqualsString(evt.target.result, fileDataAsBinaryString)).toBe(true);
                    done();
                }, done);
            });
        });
        it("file.spec.88 should read sliced file: readAsText", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsText', false, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result).toBe(fileDataAsBinaryString.slice(10, 40));
                    done();
                }, done, 10, 40);
            });
        });
        it("file.spec.89 should read sliced file: slice past eof", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsText', false, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result).toBe(fileData.slice(-5, 9999));
                    done();
                }, done, -5, 9999);
            });
        });
        it("file.spec.90 should read sliced file: slice to eof", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsText', false, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result).toBe(fileData.slice(-5));
                    done();
                }, done, -5);
            });
        });
        it("file.spec.91 should read empty slice", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsText', false, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result).toBe('');
                    done();
                }, done, 0, 0);
            });
        });
        it("file.spec.92 should read sliced file properly, readAsDataURL", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsDataURL', true, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result.slice(0, 23)).toBe("data:text/plain;base64,");
                    // TODO: See if this line is running in existing mobile spec tests
                    // It fails with INVALID_CHARACTER_ERR on Safari 6.1
                    expect(evt.target.result.slice(23)).toBe(atob(fileDataAsBinaryString.slice( 10, -3)));
                    done();
                }, done, 10, -3);
            });
        });
        it("file.spec.93 should read sliced file properly, readAsBinaryString", function(done) {
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsBinaryString', true, function(evt, fileData, fileDataAsBinaryString) {
                    expect(evt.target.result).toBe(fileDataAsBinaryString.slice(-10, -5));
                    done();
                }, done, -10, -5);
            });
        });
        it("file.spec.94 should read sliced file properly, readAsArrayBuffer", function(done) {
            // Skip test if ArrayBuffers are not supported (e.g.: Android 2.3).
            if (typeof window.ArrayBuffer == 'undefined') {
                done();
            }
            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                runReaderTest(fs.root, 'readAsArrayBuffer', true, function(evt, fileData, fileDataAsBinaryString) {
                    expect(arrayBufferEqualsString(evt.target.result, fileDataAsBinaryString.slice(0, -1))).toBe(true);
                    done();
                }, done, 0, -1);
            });
        });
    });

    describe('FileWriter', function(){
        // Previously labelled as file.spec.81
        it("file.spec.95 should have correct methods", function(done) {
            // retrieve a FileWriter object
            var fileName = "writer.methods",
                fail = createFail('FileWriter', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // test FileWriter
                fs.root.getFile(fileName, {create: true}, function(fileEntry) {
                    fileEntry.createWriter(function(writer) {
                        expect(writer).toBeDefined();
                        expect(typeof writer.write).toBe('function');
                        expect(typeof writer.seek).toBe('function');
                        expect(typeof writer.truncate).toBe('function');
                        expect(typeof writer.abort).toBe('function');

                        // cleanup
                        deleteEntry(fileEntry, done);
                    }, fail);
                }, fail);
            });
        });
        it("file.spec.96 should be able to write and append to file, createWriter", function(done) {
            var fileName = "writer.append",
                // file content
                rule = "There is an exception to every rule.",
                // for checkin file length
                length = rule.length,
                fail = createFail('FileWriter', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // create file, then write and append to it
                createFile(fs.root, fileName, function(fileEntry) {
                    // writes initial file content
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.write(rule);
                        function verifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // append some more stuff
                            var exception = "  Except this one.";
                            writer.onwriteend = anotherVerifier;
                            length += exception.length;
                            writer.seek(writer.length);
                            writer.write(exception);
                        }
                        function anotherVerifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // cleanup
                            deleteEntry(fileEntry, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.97 should be able to write and append to file, File object", function(done) {
            var fileName = "writer.append",
                // file content
                rule = "There is an exception to every rule.",
                // for checking file length
                length = rule.length;

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // create file, then write and append to it
                var file = new File();
                file.fullPath = filePath;

                // writes initial file content
                var theWriter = new FileWriter(file);
                theWriter.onwriteend = verifier;
                theWriter.write(rule);

                function verifier(evt) {
                    expect(theWriter.length).toBe(length);
                    expect(theWriter.position).toBe(length);

                    // append some more stuff
                    var exception = "  Except this one.";
                    theWriter.onwriteend = anotherVerifier;
                    length += exception.length;
                    theWriter.seek(theWriter.length);
                    theWriter.write(exception);
                }

                function anotherVerifier(evt) {
                    expect(theWriter.length).toBe(length);
                    expect(theWriter.position).toBe(length);

                    // cleanup
                    deleteFile(fs.root, fileName, done);
                }
            });
        });
        it("file.spec.98 should be able to seek to the middle of the file and write more data than file.length", function(done) {
            var fileName = "writer.seek.write",
                // file content
                rule = "This is our sentence.",
                // for iting file length
                length = rule.length,
                fail = createFail('FileWriter', done);

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // create file, then write and append to it
                createFile(fs.root, fileName, function(fileEntry) {
                    // write initial file content
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.write(rule);

                        function verifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // append some more stuff
                            var exception = "newer sentence.";
                            writer.onwriteend = anotherVerifier;
                            length = 12 + exception.length;
                            writer.seek(12);
                            writer.write(exception);
                        }

                        function anotherVerifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.99 should be able to seek to the middle of the file and write less data than file.length", function(done) {
            var fileName = "writer.seek.write2",
                // file content
                rule = "This is our sentence.",
                fail = createFail('FileWriter', done),
                // for testing file length
                length = rule.length;

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // create file, then write and append to it
                createFile(fs.root, fileName, function(fileEntry) {
                    // write initial file content
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.write(rule);

                        function verifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // append some more stuff
                            var exception = "new.";
                            writer.onwriteend = anotherVerifier;
                            length = 8 + exception.length;
                            writer.seek(8);
                            writer.write(exception);
                        }

                        function anotherVerifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.100 should be able to write XML data", function(done) {
            var fileName = "writer.xml",
                fail = createFail('FileWriter', done),
                // file content
                rule = '<?xml version="1.0" encoding="UTF-8"?>\n<test prop="ack">\nData\n</test>\n',
                // for testing file length
                length = rule.length;

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // creates file, then write XML data
                createFile(fs.root, fileName, function(fileEntry) {
                    // write file content
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.write(rule);

                        function verifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.101 should be able to write JSON data", function(done) {
            var fileName = "writer.json",
                fail = createFail('FileWriter', done),
                // file content
                rule = '{ "name": "Guy Incognito", "email": "here@there.com" }',
                // for testing file length
                length = rule.length;

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                var filePath = fs.root.fullPath + '/' + fileName;
                // creates file, then write JSON content
                createFile(fs.root, fileName, function(fileEntry) {
                    // write file content
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.write(rule);

                        function verifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.102 should be able to seek", function(done) {
            var fileName = "writer.seek",
                // file content
                rule = "There is an exception to every rule.  Except this one.",
                // for iting file length
                length = rule.length,
                fail = createFail('FileWriter');

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // creates file, then write JSON content
                createFile(fs.root, fileName, function(fileEntry) {
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.seek(-100);
                        expect(writer.position).toBe(0);
                        writer.write(rule);

                        function verifier(evt) {
                            expect(writer.position).toBe(length);
                            writer.seek(-5);
                            expect(writer.position).toBe(length-5);
                            writer.seek(length + 100);
                            expect(writer.position).toBe(length);
                            writer.seek(10);
                            expect(writer.position).toBe(10);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.103 should be able to truncate", function(done) {
            var fileName = "writer.truncate",
                rule = "There is an exception to every rule.  Except this one.",
                fail = createFail('FileWriter');

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // creates file, writes to it, then truncates it
                createFile(fs.root, fileName, function(fileEntry) {
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = truncate_file;
                        writer.write(rule);

                        function truncate_file(evt) {
                            writer.onwriteend = verifier;
                            writer.truncate(36);
                        }

                        function verifier(evt) {
                            expect(writer.length).toBe(36);
                            expect(writer.position).toBe(36);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.104 should be able to write binary data from an ArrayBuffer", function(done) {
            // Skip test if ArrayBuffers are not supported (e.g.: Android 2.3).
            if (typeof window.ArrayBuffer == 'undefined') {
                done();
            }
            var fileName = "bufferwriter.bin",
                // file content
                data = new ArrayBuffer(32),
                dataView = new Int8Array(data),
                fail = createFail('FileWriter', done),
                // for verifying file length
                length = 32;

            for (i=0; i < dataView.length; i++) {
                dataView[i] = i;
            }

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // creates file, then write content
                createFile(fs.root, fileName, function(fileEntry) {
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.write(data);

                        function verifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
        it("file.spec.105 should be able to write binary data from a Blob", function(done) {
            // Skip test if Blobs are not supported (e.g.: Android 2.3).
            if (typeof window.Blob == 'undefined' || typeof window.ArrayBuffer == 'undefined') {
                done();
            }
            var fileName = "blobwriter.bin",
                fail = createFail('FileWriter', done),
                // file content
                data = new ArrayBuffer(32),
                dataView = new Int8Array(data),
                blob,
                // for verifying file length
                length = 32;

            for (i=0; i < dataView.length; i++) {
                dataView[i] = i;
            }
            try {
                // Mobile Safari: Use Blob constructor
                blob = new Blob([data], {"type": "application/octet-stream"});
            } catch(e) {
                if (window.WebKitBlobBuilder) {
                    // Android Browser: Use deprecated BlobBuilder
                    var builder = new WebKitBlobBuilder();
                    builder.append(data);
                    blob = builder.getBlob('application/octet-stream');
                } else {
                    // We have no way defined to create a Blob, so fail
                    fail();
                }
            }

            window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
                // creates file, then write content
                createFile(fs.root, fileName, function(fileEntry) {
                    fileEntry.createWriter(function(writer) {
                        writer.onwriteend = verifier;
                        writer.write(blob);

                        function verifier(evt) {
                            expect(writer.length).toBe(length);
                            expect(writer.position).toBe(length);

                            // cleanup
                            deleteFile(fs.root, fileName, done);
                        }
                    }, fail);
                });
            });
        });
    });
});

};