diff --git a/BCL.csproj b/BCL.csproj index 0c2e8295a..d5b7d17fa 100644 --- a/BCL.csproj +++ b/BCL.csproj @@ -46,13 +46,23 @@ AnyCPU MinimumRecommendedRules.ruleset + + true + bin\ + full + AnyCPU + MinimumRecommendedRules.ruleset + + + bin\ + - True + False True 63708 / @@ -129,6 +139,12 @@ location.d.ts + + + + + + text.d.ts @@ -177,7 +193,6 @@ user_preferences.d.ts - @@ -227,9 +242,6 @@ True ES5 - - True - commonjs True @@ -242,21 +254,51 @@ True ES5 + + commonjs + ES5 + True + + + commonjs + True + ES5 + + + iOS + + iOS Deploy\xCode\Configuration.xml - app.js + bootstrap.js + + + iOS + Deploy\xCode\Configuration.xml + bootstrap.js + true + + + Android + Android Deploy\Eclipse\Configuration.xml - app.js + bootstrap.js + + + Android + Deploy\Eclipse\Configuration.xml + bootstrap.js + true - + diff --git a/BCL.sln b/BCL.sln index ccdf69ebf..ebbe7bcd1 100644 --- a/BCL.sln +++ b/BCL.sln @@ -1,24 +1,30 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 2013 -VisualStudioVersion = 12.0.30110.0 +VisualStudioVersion = 12.0.30324.0 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BCL", "BCL.csproj", "{2313F1BF-1F2D-4F11-806A-87927FA6A7C0}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Android_Deploy|Any CPU = Android_Deploy|Any CPU + Android_Tests|Any CPU = Android_Tests|Any CPU Android|Any CPU = Android|Any CPU iOS_Deploy|Any CPU = iOS_Deploy|Any CPU + iOS_Tests|Any CPU = iOS_Tests|Any CPU iOS|Any CPU = iOS|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.Android_Deploy|Any CPU.ActiveCfg = Android_Deploy|Any CPU {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.Android_Deploy|Any CPU.Build.0 = Android_Deploy|Any CPU + {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.Android_Tests|Any CPU.ActiveCfg = Android_Tests|Any CPU + {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.Android_Tests|Any CPU.Build.0 = Android_Tests|Any CPU {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.Android|Any CPU.ActiveCfg = Android|Any CPU {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.Android|Any CPU.Build.0 = Android|Any CPU {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.iOS_Deploy|Any CPU.ActiveCfg = iOS_Deploy|Any CPU {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.iOS_Deploy|Any CPU.Build.0 = iOS_Deploy|Any CPU + {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.iOS_Tests|Any CPU.ActiveCfg = iOS_Tests|Any CPU + {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.iOS_Tests|Any CPU.Build.0 = iOS_Tests|Any CPU {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.iOS|Any CPU.ActiveCfg = iOS|Any CPU {2313F1BF-1F2D-4F11-806A-87927FA6A7C0}.iOS|Any CPU.Build.0 = iOS|Any CPU EndGlobalSection diff --git a/Tests/TKUnit.ts b/Tests/TKUnit.ts new file mode 100644 index 000000000..97524c13d --- /dev/null +++ b/Tests/TKUnit.ts @@ -0,0 +1,96 @@ + +/* Notes: + + 1. all test function names should begin with 'test' + 2. (if exists) at the beginning of module test setUpModule() module function is called + 3. (if exists) at the beginning of each test setUp() module function is called + 4. tests should use TKUnit.assert(condition, message) to mark error. If no assert fails test is successful + 5. (if exists) at the end of each test tearDown() module function is called + 6. (if exists) at the end of module test tearDownModule() module function is called + +*/ + +var Application = require("Application"); + +var runTest = function(test, testName) { + test(); + console.info("--- [" + testName + "] OK"); +} + +export var runTestModule = function(module, moduleName){ + console.info("--- " + moduleName + " TESTS BEGIN ---"); + console.time(moduleName); + + try { + if (module.setUpModule) { + module.setUpModule(); + } + } + catch (e) { + console.error("--- [" + moduleName + ".setUpModule()] FAILED: " + e.message); + } + + var totalTests = 0; + var totalSuccess = 0; + for (var testName in module) { + var testFunction = module[testName]; + if ((typeof(testFunction) === "function") && (testName.substring(0, 4) == "test")) { + try { + if (module.setUp) { + module.setUp(); + } + } + catch (e) { + console.error("--- [" + moduleName + ".setUp()] FAILED: " + e.message); + } + try { + totalTests++; + runTest(testFunction, testName); + totalSuccess++; + } + catch (e) { + console.error("--- [" + testName + "] FAILED: " + e.message); + } + try { + if (module.tearDown) { + module.tearDown(); + } + } + catch (e) { + console.error("--- [" + moduleName + ".tearDown()] FAILED: " + e.message); + } + } + } + + try { + if (module.tearDownModule) { + module.tearDownModule(); + } + } + catch (e) { + console.error("--- [" + moduleName + ".tearDownModule()] FAILED: " + e.message); + } + + console.timeEnd(moduleName); + console.info("--- " + moduleName + " TESTS COMPLETE --- (" + totalSuccess + " of " + totalTests + ") OK, " + (totalTests - totalSuccess) + " failed"); +} + +export var assert = function(test: boolean, message?: string) +{ + //console.assert(test, message); + if (!test) { + throw new Error(message); + } +} + +export var wait = function(ms) +{ + if (Application.ios) { + Foundation.NSRunLoop.currentRunLoop().runUntilDate(Foundation.NSDate.dateWithTimeIntervalSinceNow(ms / 1000)); + } + else if (Application.android) { + java.lang.Thread.sleep(long(ms)); + java.lang.Thread.yield(); + } +} + \ No newline at end of file diff --git a/Tests/file_system_tests.ts b/Tests/file_system_tests.ts new file mode 100644 index 000000000..ce2c86866 --- /dev/null +++ b/Tests/file_system_tests.ts @@ -0,0 +1,428 @@ + +// +// # File System +// Using the file system requires the FileSystem module. +// ``` JavaScript +var fs = require("FileSystem"); +// ``` +// The pre-required `fs` module is used throughout the following code snippets. +// + +var TKUnit = require("TestModules/TKUnit"); + +// +// ## Create +// + +// TODO: Split the "Read and Write" in "Read" and "Write" +export var testFileReadWrite = function () { + // TODO: Add description if writeText replaces the file? Does it create the file? Does it append to existing file? + + // + // ### Writing and Reading a String to 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) { + //// Successfuly read the file's content. + // + written = content === "Something"; + TKUnit.assert(written, "File read/write not working."); + myFile.remove(); + // + }) + .fail(function (error) { + //// Failed to read from the file. + // + console.error("Failed to read/write text"); + console.dump(error); + // + }); + }) + .fail(function (error) { + //// Failed to write to the file. + // + console.error("Failed to read/write text"); + console.dump(error); + // + }); + // ``` + // +}; + +// +// ## Read +// + +export var testGetKnownFolders = function () { + // + // ### 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(); + // + TKUnit.assert(documents, "Could not retrieve the Documents known folder."); + TKUnit.assert(documents.isKnown, "The Documents folder should have its isKnown property set to true."); + // + //// Getting the application's 'temp' folder. + var temp = fs.knownFolders.temp(); + // + TKUnit.assert(temp, "Could not retrieve the Temporary known folder."); + TKUnit.assert(temp.isKnown, "The Temporary folder should have its isKnown property set to true."); + // + // ``` + // +}; + +export var testGetEntities = function () { + // + // ### Getting Folder Contents + // Getting all files and folders within a folder: + // ``` JavaScript + var documents = fs.knownFolders.documents(); + // + 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; + } + } + }; + + // + documents.getEntities() + .then(function (entities) { + //// entities is array with the document's files and folders. + entities.forEach(function (entity) { + console.log(entity.name); + }); + // + + TKUnit.assert(fileFound, "Failed to enumerate Test.txt"); + TKUnit.assert(file1Found, "Failed to enumerate Test1.txt"); + + file.remove(); + file1.remove(); + // + }) + .fail(function (error) { + //// Failed to obtain folder's contents. + // globalConsole.error(error.message); + }); + // ``` + // +}; + +export var testEnumEntities = function () { + // + // ### Enumerating Folder Contents + // Getting all folder entities in array may be slow with large number of files. + // Enumerating the folder entities would itterate the files one by one without blocking the UI. + // ``` JavaScript + var documents = fs.knownFolders.documents(); + // + var file = documents.getFile("Test.txt"); + var file1 = documents.getFile("Test1.txt"); + var fileFound, + file1Found; + var console = { + log: function (file) { + if (file === "Test.txt") { + fileFound = true; + } else if (file === "Test1.txt") { + file1Found = true; + } + } + } + // + documents.eachEntity(function (entity) { + console.log(entity.name); + }); + // + TKUnit.assert(fileFound, "Failed to enumerate Test.txt"); + TKUnit.assert(file1Found, "Failed to enumerate Test1.txt"); + + file.remove(); + file1.remove(); + // + // ``` + // +}; + +// TODO: testGetFile + +export var testGetFolder = function () { + // + // ### Getting Folder by Name + // ``` JavaScript + var documents = fs.knownFolders.documents(); + var myFolder = documents.getFolder("Tests__"); + // + TKUnit.assert(myFolder, "Folder.getFolder API not working."); + TKUnit.assert(fs.Folder.exists(myFolder.path), "Folder.getFolder API not working."); + myFolder.remove(); + // + // ``` + // +}; + +export var testGetParent = function () { + // + // ### Getting Parent Folder + // ``` JavaScript + var documents = fs.knownFolders.documents(); + var file = documents.getFile("Test.txt"); + // + TKUnit.assert(file, "Failed to create file in the Documents folder."); + // + //// The parent folder of the file would be the documents folder. + var parent = file.getParent(); + // + TKUnit.assert(documents == parent, "The parent folder should be the Documents folder."); + file.remove(); + // + // ``` + // +}; + +export var testFileNameExtension = function () { + // + // ### 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; + // + TKUnit.assert(fileName, "Test.txt"); + TKUnit.assert(fileExtension, ".txt"); + file.remove(); + // + // ``` + // +}; + +export var testFileExists = function () { + // + // ### Checking if a File Exists + // ``` JavaScript + var documents = fs.knownFolders.documents(); + var file = documents.getFile("Test.txt"); + var exists = fs.File.exists(file.path); + // + TKUnit.assert(exists, "File.exists API not working."); + exists = fs.File.exists(file.path + "_"); + TKUnit.assert(!exists, "File.exists API not working."); + file.remove(); + // + // ``` + // +}; + +export var testFolderExists = function () { + // + // ### Checking if a Folder Exists + // ``` JavaScript + var documents = fs.knownFolders.documents(); + var exists = fs.Folder.exists(documents.path); + // + TKUnit.assert(exists, "Folder.exists API not working."); + exists = fs.Folder.exists(documents.path + "_"); + TKUnit.assert(!exists, "Folder.exists API not working."); + // + // ``` + // +}; + +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(); +}; + +// +// ## Update +// + +export var testFileRename = function () { + // + // ### 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. + // + TKUnit.assert(file.name === "Test_renamed.txt", "File.rename API not working."); + file.remove(); + documents.getFile("Test.txt").remove(); + // + }) + .fail(function (error) { + //// Failed to rename the file. + // + console.error("Failed to rename file"); + // + }); + // ``` + // +}; + +export var testFolderRename = function () { + // + // ### Renaming a Folder + // ``` JavaScript + var folder = fs.knownFolders.documents(); + var myFolder = folder.getFolder("Test__"); + + myFolder.rename("Something") + .then(function (result) { + //// Successfully Renamed. + // + TKUnit.assert(myFolder.name === "Something", "Folder.rename API not working."); + myFolder.remove(); + folder.getFolder("Test__").remove(); + // + }) + .fail(function (error) { + //// Failed to rename the folder. + // + TKUnit.assert(false, "Folder.rename API not working."); + // + }); + // ``` + // +}; + +// +// ## Delete +// + +export var testFileRemove = function () { + // + // ### 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("Test.txt"); + file.remove() + .then(function (result) { + //// Success removing the file. + // + TKUnit.assert(!fs.File.exists(file.path)); + // + }) + .fail(function (error) { + //// Failed to remove the file. + // + TKUnit.assert(false, "File.remove API not working."); + // + }); + // ``` + // +}; + +export var testFolderClear = function () { + // + // ### 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"); + // + var file1 = folder.getFile("Test1.txt"); + var file2 = folder.getFile("Test2.txt"); + var emptied; + // + folder.clear() + .then(function () { + //// Successfully cleared the folder. + // + emptied = true; + // + }) + .fail(function (error) { + //// Failed to clear the folder. + // + console.error(error.message); + // + }); + // + folder.getEntities() + .then(function (entities) { + TKUnit.assert(entities.length === 0, "Failed to clear a Folder"); + folder.remove(); + }); + // + // ``` + // +}; + +// TODO: Removing a folder. + +// misc + +export var testKnownFolderRename = function () { + var folder = fs.knownFolders.documents(); + + folder.rename("Something") + .then(function (result) { + console.error("Known folders should not be renamed."); + }) + .fail(function (error) { + TKUnit.assert(true); + }); +}; + +export var testPathNormalize = function () { + var folder = fs.knownFolders.documents(); + var testPath = "///test.txt"; + var normalizedPath = fs.path.normalize(folder.path + testPath); + var expected = folder.path + "/test.txt"; + TKUnit.assert(normalizedPath === expected); +}; + +export var testPathJoin = function () { + var folder = fs.knownFolders.documents(); + var path = fs.path.join(folder.path, "myFiles", "test.txt"); + var expected = folder.path + "/myFiles/test.txt"; + TKUnit.assert(path === expected); +}; + +export var testPathSeparator = function () { + var separator = fs.path.separator; + var expected = "/"; + TKUnit.assert(separator === expected); +}; + \ No newline at end of file diff --git a/Tests/http_tests.ts b/Tests/http_tests.ts new file mode 100644 index 000000000..19a76f130 --- /dev/null +++ b/Tests/http_tests.ts @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Tests/index.ts b/Tests/index.ts new file mode 100644 index 000000000..c1e2313ca --- /dev/null +++ b/Tests/index.ts @@ -0,0 +1,2 @@ +declare var module, require; +module.exports = require("Tests/testRunner"); \ No newline at end of file diff --git a/Tests/location_tests.ts b/Tests/location_tests.ts new file mode 100644 index 000000000..54e1409c3 --- /dev/null +++ b/Tests/location_tests.ts @@ -0,0 +1,54 @@ +import TKUnit = require("Tests/TKUnit"); +import locationModule = require("Location/location"); + +var LocationManager = locationModule.LocationManager; +var Location = locationModule.Location; + +export var testIsEnabled = function () { + TKUnit.assert(LocationManager.isEnabled()); +}; + +export var testLocation = function () { + var locationReceived; + + var locationManager = new LocationManager(); + + locationManager.startLocationMonitoring(function(location) { + locationReceived = true; + }, function(error) { + console.log('Location error received: ' + error); + locationReceived = error; + } + ); + + var timeoutAfter = 50; // 5 seconds timeout + while (typeof locationReceived == 'undefined') { + if (0 >= --timeoutAfter) { + locationReceived = 'Location search timed out!'; + break; + } + TKUnit.wait(100); + } + + locationManager.stopLocationMonitoring(); + + TKUnit.assert(true === locationReceived, locationReceived); +}; + +export var testDistance = function () { + var locSofia = new Location(); + locSofia.longitude = 42.696552; + locSofia.latitude = 23.32601; + var locNewYork = new Location(); + locNewYork.longitude = 40.71448; + locNewYork.latitude = -74.00598; + var distance = LocationManager.distance(locSofia, locNewYork); + TKUnit.assert((distance > 10780000) && (distance < 10860000), "invalid distance " + distance); +}; + +export var testLastKnownLocation = function () { + var locationManager = new LocationManager(); + var lastKnownLocation = locationManager.lastKnownLocation; + TKUnit.assert((lastKnownLocation != null), "There is no last known location"); +}; + \ No newline at end of file diff --git a/Tests/testRunner.ts b/Tests/testRunner.ts new file mode 100644 index 000000000..31e64e954 --- /dev/null +++ b/Tests/testRunner.ts @@ -0,0 +1,10 @@ +var TKUnit = require("Tests/TKUnit"); +var fsTests = require("Tests/file_system_tests"); +var httpTests = require("Tests/http_tests"); +var locationTests = require("Tests/location_tests"); + +export var runAll = function () { + TKUnit.runTestModule(fsTests, "FILE SYSTEM"); + TKUnit.runTestModule(httpTests, "HTTP"); + TKUnit.runTestModule(locationTests, "LOCATION"); +} \ No newline at end of file diff --git a/_references.ts b/_references.ts index 12d04708e..e361743f5 100644 --- a/_references.ts +++ b/_references.ts @@ -1,3 +1,5 @@ /// /// -/// \ No newline at end of file +/// +/// +/// \ No newline at end of file