/* tslint:disable:no-unused-variable */

// >> file-system-require

import fs = require("file-system");

// << file-system-require

import TKUnit = require("./TKUnit");

import appModule = require("application");

import platform = require("platform");

export var testPathNormalize = function () {

// >> file-system-normalize

var documents = fs.knownFolders.documents();

var testPath = "///test.txt";

// Get a normalized path such as <folder.path>/test.txt from <folder.path>///test.txt

var normalizedPath = fs.path.normalize(documents.path + testPath);

// >> (hide)

var expected = documents.path + "/test.txt";

TKUnit.assert(normalizedPath === expected);

// << (hide)

// << file-system-normalize

};

export var testPathJoin = function () {

// >> file-system-multiple-args

var documents = fs.knownFolders.documents();

// Generate a path like <documents.path>/myFiles/test.txt

var path = fs.path.join(documents.path, "myFiles", "test.txt");

// >> (hide)

var expected = documents.path + "/myFiles/test.txt";

TKUnit.assert(path === expected);

// << (hide)

// << file-system-multiple-args

};

export var testPathSeparator = function () {

// >> file-system-separator

// An OS dependent path separator, "\" or "/".

var separator = fs.path.separator;

// >> (hide)

var expected = "/";

TKUnit.assert(separator === expected);

// << (hide)

// << file-system-separator

};

export var testFileFromPath = function () {

// >> file-system-create

var documents = fs.knownFolders.documents();

var path = fs.path.join(documents.path, "FileFromPath.txt");

var file = fs.File.fromPath(path);

// Writing text to the file.

file.writeText("Something")

.then(function () {

// Succeeded writing to the file.

// >> (hide)

file.readText()

.then(function (content) {

TKUnit.assert(content === "Something", "File read/write not working.");

file.remove();

}, function (error) {

TKUnit.assert(false, "Failed to read/write text");

//console.dump(error);

});

// << (hide)

}, function (error) {

// Failed to write to the file.

// >> (hide)

TKUnit.assert(false, "Failed to read/write text");

//console.dump(error);

// << (hide)

});

// << file-system-create

}

export var testFolderFromPath = function () {

// >> file-system-create-folder

var path = fs.path.join(fs.knownFolders.documents().path, "music");

var folder = fs.Folder.fromPath(path);

// >> (hide)

TKUnit.assert(<any>folder, "Folder.getFolder API not working.");

TKUnit.assert(fs.Folder.exists(folder.path), "Folder.getFolder API not working.");

folder.remove();

// << (hide)

// << file-system-create-folder

}

export var testFileWrite = function () {

// >> file-system-write-string

var documents = fs.knownFolders.documents();

var file = documents.getFile("Test_Write.txt");

// Writing text to the file.

file.writeText("Something")

.then(function () {

// Succeeded writing to the file.

// >> (hide)

file.readText()

.then(function (content) {

TKUnit.assert(content === "Something", "File read/write not working.");

file.remove();

}, function (error) {

TKUnit.assert(false, "Failed to read/write text");

//console.dump(error);

});

// << (hide)

}, function (error) {

// Failed to write to the file.

// >> (hide)

TKUnit.assert(false, "Failed to read/write text");

//console.dump(error);

// << (hide)

});

// << file-system-write-string

};

export var testGetFile = function () {

// >> file-system-create-file

var documents = fs.knownFolders.documents();

var file = documents.getFile("NewFileToCreate.txt");

// >> (hide)

TKUnit.assert(<any>file, "File.getFile API not working.");

TKUnit.assert(fs.File.exists(file.path), "File.getFile API not working.");

file.remove();

// << (hide)

// << file-system-create-file

}

export var testGetFolder = function () {

// >> file-system-get-folder

var documents = fs.knownFolders.documents();

var folder = documents.getFolder("NewFolderToCreate");

// >> (hide)

TKUnit.assert(<any>folder, "Folder.getFolder API not working.");

TKUnit.assert(fs.Folder.exists(folder.path), "Folder.getFolder API not working.");

folder.remove();

// << (hide)

// << file-system-get-folder

};

export var testFileRead = function () {

// >> file-system-example-text

var documents = fs.knownFolders.documents();

var myFile = documents.getFile("Test_Write.txt");

var written: boolean;

// Writing text to the file.

myFile.writeText("Something")

.then(function () {

// Succeeded writing to the file.

// Getting back the contents of the file.

myFile.readText()

.then(function (content) {

// Successfully read the file's content.

// >> (hide)

written = content === "Something";

TKUnit.assert(written, "File read/write not working.");

myFile.remove();

// << (hide)

}, function (error) {

// Failed to read from the file.

// >> (hide)

TKUnit.assert(false, "Failed to read/write text");

//console.dump(error);

// << (hide)

});

}, function (error) {

// Failed to write to the file.

// >> (hide)

TKUnit.assert(false, "Failed to read/write text");

//console.dump(error);

// << (hide)

});

// << file-system-example-text

};

export var testFileReadWriteBinary = function () {

// >> file-system-read-binary

var fileName = "logo.png";

var error;

var sourceFile = fs.File.fromPath(__dirname + "/" + fileName);

var destinationFile = fs.knownFolders.documents().getFile(fileName);

var source = sourceFile.readSync(e=> { error = e; });

destinationFile.writeSync(source, e=> { error = e; });

// >> (hide)

var destination = destinationFile.readSync(e=> { error = e; });

TKUnit.assertNull(error);

if (platform.device.os === platform.platformNames.ios) {

TKUnit.assertTrue(source.isEqualToData(destination));

} else {

TKUnit.assertEqual(new java.io.File(sourceFile.path).length(), new java.io.File(destinationFile.path).length());

}

destinationFile.removeSync();

// << (hide)

// << file-system-read-binary

};

export var testGetKnownFolders = function () {

// >> file-system-known-folders

// Getting the application's 'documents' folder.

var documents = fs.knownFolders.documents();

// >> (hide)

TKUnit.assert(<any>documents, "Could not retrieve the Documents known folder.");

TKUnit.assert(documents.isKnown, "The Documents folder should have its isKnown property set to true.");

// << (hide)

// Getting the application's 'temp' folder.

var temp = fs.knownFolders.temp();

// >> (hide)

TKUnit.assert(<any>temp, "Could not retrieve the Temporary known folder.");

TKUnit.assert(temp.isKnown, "The Temporary folder should have its isKnown property set to true.");

// << (hide)

// << file-system-known-folders

};

function _testIOSSpecificKnownFolder(knownFolderName: string){

let knownFolder: fs.Folder;

let createdFile: fs.File;

let testFunc = function testFunc(){

knownFolder = fs.knownFolders.ios[knownFolderName]();

if (knownFolder) {

createdFile = knownFolder.getFile("createdFile");

createdFile.writeTextSync("some text");

}

};

if (platform.isIOS){

testFunc();

if (knownFolder) {

TKUnit.assertTrue(knownFolder.isKnown, `The ${knownFolderName} folder should have its "isKnown" property set to true.`);

TKUnit.assertNotNull(createdFile, `Could not create a new file in the ${knownFolderName} known folder.`);

TKUnit.assertTrue(fs.File.exists(createdFile.path), `Could not create a new file in the ${knownFolderName} known folder.`);

TKUnit.assertEqual(createdFile.readTextSync(), "some text", `The contents of the new file created in the ${knownFolderName} known folder are not as expected.`);

}

}

else {

TKUnit.assertThrows(testFunc,

`Trying to retrieve the ${knownFolderName} known folder on a platform different from iOS should throw!`,

`The "${knownFolderName}" known folder is available on iOS only!`);

}

}

export var testIOSSpecificKnownFolders = function () {

_testIOSSpecificKnownFolder("library");

_testIOSSpecificKnownFolder("developer");

_testIOSSpecificKnownFolder("desktop");

_testIOSSpecificKnownFolder("downloads");

_testIOSSpecificKnownFolder("movies");

_testIOSSpecificKnownFolder("music");

_testIOSSpecificKnownFolder("pictures");

_testIOSSpecificKnownFolder("sharedPublic");

}

export var testGetEntities = function () {

// >> file-system-folders-content

var documents = fs.knownFolders.documents();

// >> (hide)

var file = documents.getFile("Test.txt");

var file1 = documents.getFile("Test1.txt");

var fileFound,

file1Found;

// IMPORTANT: console.log is mocked to make the snippet pretty.

var globalConsole = console;

var console = {

log: function (file) {

if (file === "Test.txt") {

fileFound = true;

} else if (file === "Test1.txt") {

file1Found = true;

}

}

};

// << (hide)

documents.getEntities()

.then(function (entities) {

// entities is array with the document's files and folders.

entities.forEach(function (entity) {

console.log(entity.name);

});

// >> (hide)

TKUnit.assert(fileFound, "Failed to enumerate Test.txt");

TKUnit.assert(file1Found, "Failed to enumerate Test1.txt");

file.remove();

file1.remove();

// << (hide)

}, function (error) {

// Failed to obtain folder's contents.

// globalConsole.error(error.message);

});

// << file-system-folders-content

};

export var testEnumEntities = function () {

// >> file-system-enum-content

var documents = fs.knownFolders.documents();

// >> (hide)

var file = documents.getFile("Test.txt");

var file1 = documents.getFile("Test1.txt");

var testFolder = documents.getFolder("testFolder");

var fileFound = false;

var file1Found = false;

var testFolderFound = false;

var console = {

log: function (file) {

if (file === "Test.txt") {

fileFound = true;

} else if (file === "Test1.txt") {

file1Found = true;

} else if (file === "testFolder") {

testFolderFound = true;

}

}

}

// << (hide)

documents.eachEntity(function (entity) {

console.log(entity.name);

// Return true to continue, or return false to stop the iteration.

return true;

});

// >> (hide)

TKUnit.assert(fileFound, "Failed to enumerate Test.txt");

TKUnit.assert(file1Found, "Failed to enumerate Test1.txt");

TKUnit.assert(testFolderFound, "Failed to enumerate testFolder");

file.remove();

file1.remove();

testFolder.remove();

// << (hide)

// << file-system-enum-content

};

export var testGetParent = function () {

// >> file-system-parent

var documents = fs.knownFolders.documents();

var file = documents.getFile("Test.txt");

// >> (hide)

TKUnit.assert(<any>file, "Failed to create file in the Documents folder.");

// << (hide)

// The parent folder of the file would be the documents folder.

var parent = file.parent;

// >> (hide)

TKUnit.assert(documents === parent, "The parent folder should be the Documents folder.");

file.remove();

// << (hide)

// << file-system-parent

};

export var testFileNameExtension = function () {

// >> file-system-extension

var documents = fs.knownFolders.documents();

var file = documents.getFile("Test.txt");

// Getting the file name "Test.txt".

var fileName = file.name;

// Getting the file extension ".txt".

var fileExtension = file.extension;

// >> (hide)

TKUnit.assert(fileName === "Test.txt", "Wrong file name.");

TKUnit.assert(fileExtension === ".txt", "Wrong extension.");

file.remove();

// << (hide)

// << file-system-extension

};

export var testFileExists = function () {

// >> file-system-fileexists

var documents = fs.knownFolders.documents();

var filePath = fs.path.join(documents.path, "Test.txt");

var exists = fs.File.exists(filePath);

// >> (hide)

TKUnit.assert(!exists, "File.exists API not working.");

var file = documents.getFile("Test.txt");

exists = fs.File.exists(file.path);

TKUnit.assert(exists, "File.exists API not working.");

file.remove();

// << (hide)

// << file-system-fileexists

};

export var testFolderExists = function () {

// >> file-system-folderexists

var documents = fs.knownFolders.documents();

var exists = fs.Folder.exists(documents.path);

// >> (hide)

TKUnit.assert(exists, "Folder.exists API not working.");

exists = fs.Folder.exists(documents.path + "_");

TKUnit.assert(!exists, "Folder.exists API not working.");

// << (hide)

// << file-system-folderexists

};

export var testContainsFile = function () {

var folder = fs.knownFolders.documents();

var file = folder.getFile("Test.txt");

var contains = folder.contains("Test.txt");

TKUnit.assert(contains, "Folder.contains API not working.");

contains = folder.contains("Test_xxx.txt");

TKUnit.assert(!contains, "Folder.contains API not working.");

file.remove();

};

export var testFileRename = function () {

// >> file-system-renaming

var documents = fs.knownFolders.documents();

var file = documents.getFile("Test.txt");

file.rename("Test_renamed.txt")

.then(function (result) {

// Successfully Renamed.

// >> (hide)

TKUnit.assert(file.name === "Test_renamed.txt", "File.rename API not working.");

file.remove();

documents.getFile("Test.txt").remove();

// << (hide)

}, function (error) {

// Failed to rename the file.

// >> (hide)

TKUnit.assert(false, "Failed to rename file");

// << (hide)

});

// << file-system-renaming

};

export var testFolderRename = function () {

// >> file-system-renaming-folder

var folder = fs.knownFolders.documents();

var myFolder = folder.getFolder("Test__");

myFolder.rename("Something")

.then(function (result) {

// Successfully Renamed.

// >> (hide)

TKUnit.assert(myFolder.name === "Something", "Folder.rename API not working.");

myFolder.remove();

folder.getFolder("Test__").remove();

// << (hide)

}, function (error) {

// Failed to rename the folder.

// >> (hide)

TKUnit.assert(false, "Folder.rename API not working.");

// << (hide)

});

// << file-system-renaming-folder

};

export var testFileRemove = function () {

// >> file-system-remove-file

var documents = fs.knownFolders.documents();

var file = documents.getFile("AFileToRemove.txt");

file.remove()

.then(function (result) {

// Success removing the file.

// >> (hide)

TKUnit.assert(!fs.File.exists(file.path));

// << (hide)

}, function (error) {

// Failed to remove the file.

// >> (hide)

TKUnit.assert(false, "File.remove API not working.");

// << (hide)

});

// << file-system-remove-file

};

export var testFolderRemove = function () {

// >> file-system-remove-folder

var documents = fs.knownFolders.documents();

var file = documents.getFolder("AFolderToRemove");

// Remove a folder and recursively its content.

file.remove()

.then(function (result) {

// Success removing the folder.

// >> (hide)

TKUnit.assert(!fs.File.exists(file.path));

// << (hide)

}, function (error) {

// Failed to remove the folder.

// >> (hide)

TKUnit.assert(false, "File.remove API not working.");

// << (hide)

});

// << file-system-remove-folder

}

export var testFolderClear = function () {

// >> file-system-clear-folder

var documents = fs.knownFolders.documents();

var folder = documents.getFolder("testFolderEmpty");

// >> (hide)

folder.getFile("Test1.txt");

folder.getFile("Test2.txt");

var subfolder = folder.getFolder("subfolder");

var emptied;

// << (hide)

folder.clear()

.then(function () {

// Successfully cleared the folder.

// >> (hide)

emptied = true;

// << (hide)

}, function (error) {

// Failed to clear the folder.

// >> (hide)

TKUnit.assert(false, error.message);

// << (hide)

});

// >> (hide)

folder.getEntities()

.then(function (entities) {

TKUnit.assertEqual(entities.length, 0, `${entities.length} entities left after clearing a folder.`);

folder.remove();

});

// << (hide)

// << file-system-clear-folder

};

// misc

export var testKnownFolderRename = function () {

// You can rename known folders in android - so skip this test.

if (!appModule.android) {

var folder = fs.knownFolders.documents();

folder.rename("Something")

.then(function (result) {

TKUnit.assert(false, "Known folders should not be renamed.");

}, function (error) {

TKUnit.assert(true);

});

}

};

export function testKnownFolderRemove(done) {

var result;

var knownFolder = fs.knownFolders.temp();

knownFolder.remove().then(

function () {

done(new Error("Remove known folder should resolve as error."));

},

function (error) {

done(null);

});

};

export function test_FSEntity_Properties() {

var documents = fs.knownFolders.documents();

var file = documents.getFile("Test_File.txt");

TKUnit.assert(file.extension === ".txt", "FileEntity.extension not working.");

TKUnit.assert(file.isLocked === false, "FileEntity.isLocked not working.");

TKUnit.assert(file.lastModified instanceof Date, "FileEntity.lastModified not working.");

TKUnit.assert(file.name === "Test_File.txt", "FileEntity.name not working.");

TKUnit.assert(file.parent === documents, "FileEntity.parent not working.");

file.remove();

}

export function test_UnlockAfterWrite(done) {

var file = fs.knownFolders.documents().getFile("Test_File_Lock.txt");

file.writeText("Hello World!").then(() => {

return file.readText();

}).then(value => {

TKUnit.assert(value === "Hello World!");

return file.remove();

}).then(() => done())

.catch(done);

}

export function test_CreateParentOnNewFile(done) {

var documentsFolderName = fs.knownFolders.documents().path;

var tempFileName = fs.path.join(documentsFolderName, "folder1", "folder2", "Test_File_Create_Parent.txt");

var file = fs.File.fromPath(tempFileName);

file.writeText("Hello World!").then(() => {

return fs.knownFolders.documents().getFolder("folder1").remove();

}).then(() => done())

.catch(done);

}

export function test_FolderClear_RemovesEmptySubfolders(done) {

let documents = fs.knownFolders.documents();

let rootFolder = documents.getFolder("rootFolder");

let emptySubfolder = rootFolder.getFolder("emptySubfolder");

TKUnit.assertTrue(fs.Folder.exists(emptySubfolder.path), "emptySubfolder should exist before parent folder is cleared.");

rootFolder.clear().then(

() => {

TKUnit.assertFalse(fs.File.exists(emptySubfolder.path), "emptySubfolder should not exist after parent folder was cleared.");

rootFolder.remove();

done();

})

.catch(done);

}