mirror of
https://github.com/NativeScript/NativeScript.git
synced 2025-08-16 03:31:45 +08:00
641 lines
21 KiB
TypeScript
641 lines
21 KiB
TypeScript
/* tslint:disable:no-unused-variable */
|
|
// <snippet module="file-system" title="file-system">
|
|
// # File System
|
|
// Using the file system requires the FileSystem module.
|
|
// ``` JavaScript
|
|
import fs = require("file-system");
|
|
// ```
|
|
// The pre-required `fs` module is used throughout the following code snippets.
|
|
// </snippet>
|
|
|
|
import TKUnit = require("./TKUnit");
|
|
import appModule = require("application");
|
|
import platform = require("platform");
|
|
|
|
// <snippet module="file-system" title="file-system">
|
|
// ## Path
|
|
// </snippet>
|
|
|
|
export var testPathNormalize = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Normalize a Path
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testPathJoin = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Path Join
|
|
// Concatenate a path to a file by providing multiple path arguments.
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testPathSeparator = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Get the Path Separator
|
|
// ``` JavaScript
|
|
//// An OS dependent path separator, "\" or "/".
|
|
var separator = fs.path.separator;
|
|
// <hide>
|
|
var expected = "/";
|
|
TKUnit.assert(separator === expected);
|
|
// </hide>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testFileFromPath = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Get or Create a File With Path
|
|
// The following example writes some text to a file created for path.
|
|
// It will create a new file or overwrite an existing file.
|
|
// ``` JavaScript
|
|
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>
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
}
|
|
|
|
export var testFolderFromPath = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Get or Create a Folder With Path
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
}
|
|
|
|
// <snippet module="file-system" title="file-system">
|
|
// ## Create
|
|
// </snippet>
|
|
|
|
export var testFileWrite = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Writing a string to a File
|
|
// The following example writes some text to a file.
|
|
// It will create a new file or overwrite an existing file.
|
|
// ``` JavaScript
|
|
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>
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testGetFile = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Get or Create a File
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
}
|
|
|
|
export var testGetFolder = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Get or Create a Folder
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
// <snippet module="file-system" title="file-system">
|
|
// ## Read
|
|
// </snippet>
|
|
|
|
export var testFileRead = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Reading from a File
|
|
// The following example writes some text to a file and then reads it back.
|
|
// ``` JavaScript
|
|
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>
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testFileReadWriteBinary = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Reading/writing binary data from/to a File
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testGetKnownFolders = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Getting the Known Folders
|
|
// Each app has several well known folders. This is how to access them:
|
|
// ``` JavaScript
|
|
//// 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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testGetEntities = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Getting Folder Contents
|
|
// Getting all files and folders within a folder:
|
|
// ``` JavaScript
|
|
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);
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testEnumEntities = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Enumerating Folder Contents
|
|
// Getting all folder entities in array may be slow with large number of files.
|
|
// Enumerating the folder entities would iterate the files one by one without blocking the UI.
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testGetParent = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Getting Parent Folder
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testFileNameExtension = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Getting File Name and Extension
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testFileExists = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Checking if a File Exists
|
|
// ``` JavaScript
|
|
var documents = fs.knownFolders.documents();
|
|
var file = documents.getFile("Test.txt");
|
|
var exists = fs.File.exists(file.path);
|
|
// <hide>
|
|
TKUnit.assert(exists, "File.exists API not working.");
|
|
exists = fs.File.exists(file.path + "_");
|
|
TKUnit.assert(!exists, "File.exists API not working.");
|
|
file.remove();
|
|
// </hide>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testFolderExists = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Checking if a Folder Exists
|
|
// ``` JavaScript
|
|
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>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
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();
|
|
};
|
|
|
|
// <snippet module="file-system" title="file-system">
|
|
// ## Update
|
|
// </snippet>
|
|
|
|
export var testFileRename = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Renaming a File
|
|
// ``` JavaScript
|
|
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>
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testFolderRename = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Renaming a Folder
|
|
// ``` JavaScript
|
|
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>
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
// <snippet module="file-system" title="file-system">
|
|
// ## Delete
|
|
// </snippet>
|
|
|
|
export var testFileRemove = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Removing a File
|
|
// To 'delete', 'remove' or 'unlink' a file use the file's remove method:
|
|
// ``` JavaScript
|
|
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>
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
export var testFolderRemove = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Removing a Folder
|
|
// ``` JavaScript
|
|
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>
|
|
});
|
|
// ```
|
|
// </snippet>
|
|
}
|
|
|
|
export var testFolderClear = function () {
|
|
// <snippet module="file-system" title="file-system">
|
|
// ### Clearing the Contents of a Folder
|
|
// The clear method removes all files within a folder.
|
|
// ``` JavaScript
|
|
var documents = fs.knownFolders.documents();
|
|
var folder = documents.getFolder("testFolderEmpty");
|
|
// <hide>
|
|
folder.getFile("Test1.txt");
|
|
folder.getFile("Test2.txt");
|
|
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.assert(entities.length === 0, "Failed to clear a Folder");
|
|
folder.remove();
|
|
});
|
|
// </hide>
|
|
// ```
|
|
// </snippet>
|
|
};
|
|
|
|
// 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);
|
|
} |