cordova-sqlite-evmax-build-free 0.0.7 → 0.0.9

package/AUTHORS.md

@@ -14,6 +14,7 @@
 
 - Extracted from DroidGap by @brodybits (Chris Brody)
 - Transaction batch processing of Android version by @marcucio
+- Updated for Android 11 by @brodybits (Chris Brody)
 - Maintained by @brodybits (Chris Brody)
 - Fixes to support old Android versions by @nolanlawson
 - Thanks to Mark Oppenheim <mark.oppenheim@mnetics.co.uk> for fixes to open/close callbacks and repeated open/close/delete operations

package/CHANGES.md

@@ -1,5 +1,31 @@
 # Changes
 
+# cordova-sqlite-evmax-build-free 0.0.9
+
+- Custom Android database file location - now merged into cordova-sqlite-evmax-build-free
+- SQLite 3.43.1 update, with `SQLITE_ENABLE_MATH_FUNCTIONS` enabled for Android/iOS/Windows
+- build cleanup: remove extra dummy WinMD (etc.)
+
+## cordova-sqlite-evmax-feat-android-db-location 0.0.2-dev
+
+## cordova-sqlite-evmax-common-free 0.0.7-dev
+
+- _SQLite3 math functions now tested for Android/iOS/Windows_
+
+### cordova-sqlite-evcore-common-free 0.7.3-dev
+
+- enable SQLite3 math functions for Windows (and update test case)
+
+### cordova-sqlite-evcore-common-free 0.7.2-dev
+
+- enable SQLite3 math functions for iOS (only), with new test case feature ref: https://www.sqlite.org/lang_mathfunc.html
+
+# cordova-sqlite-evmax-build-free 0.0.8
+
+## cordova-sqlite-evmax-common-free 0.0.6-dev
+
+- fix workaround for slash characters with Capacitor
+
 # cordova-sqlite-evmax-build-free 0.0.7
 
 ## cordova-sqlite-evmax-common-free 0.0.5-dev
@@ -67,6 +93,12 @@
   - update affected test cases
   - update documentation
 
+## cordova-sqlite-evplus-feat-android-db-location 0.0.2-dev
+
+## cordova-sqlite-evcore-feat-android-db-location 0.8.0
+
+- refactor: update androidDatabaseLocation error messages
+
 ### cordova-sqlite-evcore-commoncore-free 0.3.0
 
 ### cordova-sqlite-ext-common 4.0.0
@@ -83,6 +115,12 @@
   - http://sqlite.1065341.n5.nabble.com/Crash-Bug-Report-tc109903.html
   - https://github.com/xpbrew/cordova-sqlite-storage/issues/904
 
+## cordova-sqlite-evplus-feat-android-db-location 0.0.1-dev
+
+### cordova-sqlite-evcore-feature-android-db-location 0.7.2-dev1
+
+- Custom Android database file location
+
 ## cordova-plugin-sqlite-evplus-ext-common-free 0.4.1-rc01
 
 - SQLite 3.32.3 update from github:brodybits/cordova-sqlite-evplus-ext-free-dependencies#0.1.0-rc02

package/LICENSE.md

@@ -18,7 +18,7 @@ sqlite3-regexp-cached - adapted by @brodybits (Christopher J. Brody), based on s
 
 sqlite3-base64 by @brodybits (Christopher J. Brody), Unlicense (http://unlicense.org/ - public domain)
 
-libb64-encode - based on libb64 (http://libb64.sourceforge.net/) by Chris Venter, public domain
+libb64-core - based on libb64 (http://libb64.sourceforge.net/) by Chris Venter, public domain
 
 MIT or Apache 2.0
 
@@ -36,7 +36,7 @@ Based on <http://git.altlinux.org/people/at/packages/?p=sqlite3-pcre.git> by Ale
 
 Unlicense (public domain)
 
-### libb64-encode
+### libb64-core
 
 Based on <http://libb64.sourceforge.net/> by Chris Venter, public domain)
 

package/README.md

@@ -1,4 +1,4 @@
-# Cordova/PhoneGap sqlite storage evmax - super-premium enterprise version with super-premium stability and performance improvements with limited extra features
+# Cordova/PhoneGap sqlite storage evmax - super-premium enterprise version with super-premium stability and performance improvements with EXTRA FEATURES INCLUDING ARBITRARY ANDROID DB LOCATION
 
 Native SQLite component with API based on HTML5/[Web SQL (DRAFT) API](http://www.w3.org/TR/webdatabase/) for the following platforms:
 - Android
@@ -201,7 +201,7 @@ See the [Sample section](#sample) for a sample with a more detailed explanation
 - This plugin version includes the following extra (non-standard) features:
   - BASE64 and BLOBFROMBASE64 integrated from [brodybits / sqlite3-base64](https://github.com/brodybits/sqlite3-base64), using [brodybits / libb64-core](https://github.com/brodybits/libb64-core) (based on <http://libb64.sourceforge.net/> by Chris Venter, public domain)
   - REGEXP for Android (default Android-sqlite-connector database implementation), iOS, and macOS using [brodybits / sqlite3-regexp-cached](https://github.com/brodybits/sqlite3-regexp-cached) (based on <http://git.altlinux.org/people/at/packages/?p=sqlite3-pcre.git> by Alexey Tourbin, public domain)
-- SQLite __`3.40.0`__ included when building (all platforms), with the following compile-time definitions:
+- SQLite __`3.43.1`__ included when building (all platforms), with the following compile-time definitions:
   - `SQLITE_THREADSAFE=1`
   - `SQLITE_DEFAULT_SYNCHRONOUS=3` (EXTRA DURABLE build setting) ref: [xpbrew/cordova-sqlite-storage#736](https://github.com/xpbrew/cordova-sqlite-storage/issues/736)
   - `SQLITE_LOCKING_STYLE=1` on iOS/macOS ONLY
@@ -220,6 +220,7 @@ See the [Sample section](#sample) for a sample with a more detailed explanation
   - `SQLITE_ENABLE_RTREE`
   - `SQLITE_ENABLE_JSON1`
   - `SQLITE_ENABLE_RTREE`
+  - `SQLITE_ENABLE_MATH_FUNCTIONS` - _Android/iOS/Windows_
   - `SQLITE_DEFAULT_PAGE_SIZE=4096` - new default page size ref: <http://sqlite.org/pgszchng2016.html>
   - `SQLITE_DEFAULT_CACHE_SIZE=-2000` - new default cache size ref: <http://sqlite.org/pgszchng2016.html>
   - `SQLITE_OS_WINRT` (Windows only)
@@ -263,6 +264,7 @@ See the [Sample section](#sample) for a sample with a more detailed explanation
 
 - This plugin version includes super-premium workarounds to support super-large INSERT transactions on Android and resolve an issue with `/` character in Capacitor. It also includes premium improvements to the internal JSON interface between Javascript and native parts on Android, iOS, and macOS which improves the performance and resolves memory issues in case of some very large SQL batches and large SELECT results, with help from [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) on Android.
 - This plugin version includes additional JavaScript performance enhancements with special benefit for Android.
+- Custom Android database location (supports external storage directory)
 - This plugin version includes the following extra (non-standard) features: BASE 64 (all platforms Android/iOS/macOS/Windows), REGEXP (Android/iOS/macOS)
 - Using `SQLITE_DEFAULT_SYNCHRONOUS=3` (EXTRA DURABLE) build setting to be extra robust against possible database corruption ref: [xpbrew/cordova-sqlite-storage#736](https://github.com/xpbrew/cordova-sqlite-storage/issues/736)
 - `SQLITE_DBCONFIG_DEFENSIVE` flag is used for extra SQL safety, as described above
@@ -855,6 +857,32 @@ where the `iosDatabaseLocation` option may be set to one of the following choice
 - `Library`: `Library` subdirectory - backed up by iCloud, *NOT* visible to iTunes
 - `Documents`: `Documents` subdirectory - visible to iTunes and backed up by iCloud
 
+To specify a external or another custom Android database location, with help from cordova-plugin-file:
+
+```js
+window.resolveLocalFileSystemURL(cordova.file.externalDataDirectory, function(externalDataDirectoryEntry) {
+  var db = window.sqlitePlugin.openDatabase({name: 'external.db', androidDatabaseLocation: externalDataDirectoryEntry.toURL()});
+
+  db.transaction(function(tx) {
+    tx.executeSql('CREATE TABLE IF NOT EXISTS MyTable (data)');
+    tx.executeSql('INSERT INTO MyTable VALUES (?)', ['test-value']);
+  }, function(error) {
+    console.log('Populate database error: ' + error.message);
+
+  }, function() {
+    db.transaction(function(tx) {
+      tx.executeSql('SELECT data from MyTable', [], function(tx_ignored, resultSet) {
+        console.log('Record count: ' + resultSet.rows.length);
+        for (var i=0; i<resultSet.rows.length; ++i)
+          console.log('index: ' + i + ' value: ' + resultSet.rows.item(i).data);
+      });
+    }, function(error) {
+      console.log('Populate database error: ' + error.message);
+    });
+  });
+});
+```
+
 **WARNING:** Again, the new "default" iosDatabaseLocation value is *NOT* the same as the old default location and would break an upgrade for an app using the old default value (0) on iOS.
 
 DEPRECATED ALTERNATIVE to be removed in an upcoming release:

package/SQLitePlugin.coffee.md

@@ -23,6 +23,9 @@
 
     EE_SIZE_LIMIT = 16 * 1024 * 1024
 
+    REPLACE_BANG_REGEXP = /!/g
+    REPLACE_SLASH_REGEXP = /\//g
+
 ## global(s):
 
     # per-db map of locking and queueing
@@ -456,8 +459,7 @@
           t = typeof v
           flatlist.push(
             if v == null || v == undefined then null
-            else if t == 'number' then v
-            else if t == 'string' then v.replace('!', '!!').replace('/', '!|')
+            else if t == 'number' || t == 'string' then v
             else v.toString()
           )
 
@@ -707,7 +709,11 @@
 
         flatlist = [mydbid, flen]
 
-        flatlist = flatlist.concat flatBatchExecutesEntries[index]
+        flatlist = flatlist.concat flatBatchExecutesEntries[index].map (v) ->
+          if typeof v == 'string'
+            v.replace(REPLACE_BANG_REGEXP, '!1').replace(REPLACE_SLASH_REGEXP, '!2')
+          else
+            v
 
         flatlist.push 'extra'
 
@@ -901,17 +907,22 @@
         if !openargs.name
           throw newSQLError 'Database name value is missing in openDatabase call'
 
-        if !openargs.iosDatabaseLocation and !openargs.location and openargs.location isnt 0
-          throw newSQLError 'Database location or iosDatabaseLocation setting is now mandatory in openDatabase call.'
+        if !openargs.iosDatabaseLocation and !openargs.location and openargs.location isnt 0 and !openargs.androidDatabaseLocation
+          throw newSQLError 'Database location (or iosDatabaseLocation or androidDatabaseLocation) setting is now mandatory in openDatabase call.'
 
         if !!openargs.location and !!openargs.iosDatabaseLocation
           throw newSQLError 'AMBIGUOUS: both location and iosDatabaseLocation settings are present in openDatabase call. Please use either setting, not both.'
 
+        if !!openargs.location and !!openargs.androidDatabaseLocation
+          throw newSQLError 'AMBIGUOUS: both location and androidDatabaseLocation settings are present in openDatabase call. Please use either setting, not both. But you *can* use androidDatabaseLocation and iosDatabaseLocation together.'
+
         dblocation =
           if !!openargs.location and openargs.location is 'default'
             iosLocationMap['default']
           else if !!openargs.iosDatabaseLocation
             iosLocationMap[openargs.iosDatabaseLocation]
+          else if !openargs.location and openargs.location isnt 0
+            iosLocationMap['default']
           else
             dblocations[openargs.location]
 
@@ -978,17 +989,22 @@
           #args.dblocation = dblocation || dblocations[0]
           #args.dblocation = dblocation || dblocations[2]
 
-        if !first.iosDatabaseLocation and !first.location and first.location isnt 0
-          throw newSQLError 'Database location or iosDatabaseLocation setting is now mandatory in deleteDatabase call.'
+        if !first.iosDatabaseLocation and !first.location and first.location isnt 0 and !first.androidDatabaseLocation
+          throw newSQLError 'Database location (or iosDatabaseLocation or androidDatabaseLocation) setting is now mandatory in deleteDatabase call.'
 
         if !!first.location and !!first.iosDatabaseLocation
           throw newSQLError 'AMBIGUOUS: both location and iosDatabaseLocation settings are present in deleteDatabase call. Please use either setting value, not both.'
 
+        if !!first.location and !!first.androidDatabaseLocation
+          throw newSQLError 'AMBIGUOUS: both location and androidDatabaseLocation settings are present in deleteDatabase call. Please use either setting, not both. But you *can* use androidDatabaseLocation and iosDatabaseLocation together.'
+
         dblocation =
           if !!first.location and first.location is 'default'
             iosLocationMap['default']
           else if !!first.iosDatabaseLocation
             iosLocationMap[first.iosDatabaseLocation]
+          else if !first.location and first.location isnt 0
+            iosLocationMap['default']
           else
             dblocations[first.location]
 
@@ -996,6 +1012,8 @@
           throw newSQLError 'Valid iOS database location could not be determined in deleteDatabase call'
 
         args.dblocation = dblocation
+        if !!first.androidDatabaseLocation
+          args.androidDatabaseLocation = first.androidDatabaseLocation
 
         # XXX TODO BUG litehelpers/Cordova-sqlite-storage#367 (repeated here):
         # abort all pending transactions (with error callback)

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "cordova-sqlite-evmax-build-free",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Cordova/PhoneGap sqlite storage - free evmax enterprise version with premium stability and performance improvements including workaround for super-large INSERT transactions & SELECT results on Android (version with external sqlite3 dependencies)",
   "cordova": {
-    "id": "cordova-sqlite-evmax-common-free",
+    "id": "cordova-sqlite-evmax-build-free",
     "platforms": [
       "android",
       "ios",

package/plugin.xml

@@ -2,7 +2,7 @@
 <plugin xmlns="http://www.phonegap.com/ns/plugins/1.0"
     xmlns:android="http://schemas.android.com/apk/res/android"
     id="cordova-sqlite-evmax-build-free"
-    version="0.0.7">
+    version="0.0.9">
 
     <name>Cordova sqlite storage - free evmax common version branch with premium stability performance improvements including workaround for super-large INSERT transactions and SELECT results on Android (with external sqlite3 dependencies)</name>
 
@@ -66,7 +66,7 @@
 
         <header-file src="src/deps/common/sqlite3.h" />
         <source-file src="src/deps/common/sqlite3.c"
-                     compiler-flags="-w -DSQLITE_THREADSAFE=1 -DSQLITE_DEFAULT_SYNCHRONOUS=3 -DSQLITE_LOCKING_STYLE=1 -DHAVE_USLEEP=1 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_OMIT_DECLTYPE -DSQLITE_OMIT_DEPRECATED -DSQLITE_OMIT_PROGRESS_CALLBACK -DSQLITE_OMIT_SHARED_CACHE -DSQLITE_TEMP_STORE=2 -DSQLITE_OMIT_LOAD_EXTENSION -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_FTS3_PARENTHESIS -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5 -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_JSON1 -DSQLITE_DEFAULT_PAGE_SIZE=4096 -DSQLITE_DEFAULT_CACHE_SIZE=-2000" />
+                     compiler-flags="-w -DSQLITE_THREADSAFE=1 -DSQLITE_DEFAULT_SYNCHRONOUS=3 -DSQLITE_LOCKING_STYLE=1 -DHAVE_USLEEP=1 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_OMIT_DECLTYPE -DSQLITE_OMIT_DEPRECATED -DSQLITE_OMIT_PROGRESS_CALLBACK -DSQLITE_OMIT_SHARED_CACHE -DSQLITE_TEMP_STORE=2 -DSQLITE_OMIT_LOAD_EXTENSION -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_FTS3_PARENTHESIS -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5 -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MATH_FUNCTIONS -DSQLITE_DEFAULT_PAGE_SIZE=4096 -DSQLITE_DEFAULT_CACHE_SIZE=-2000" />
     </platform>
 
     <!-- macOS (osx) -->
@@ -122,9 +122,9 @@
              - https://www.dynamsoft.com/codepool/cordova-plugin-barcode-winrt.html
              - https://github.com/yushulx/cordova-windows-barcode
              - -->
-        <framework src="src/windows/libs/x86/BarcodeComponent.winmd" target-dir="x86" arch="x86" custom="true"/>
+        <framework src="src/windows/libs/dummy/BarcodeComponent.winmd" target-dir="x86" arch="x86" custom="true"/>
         <framework src="src/windows/libs/x86/SQLite3.winmd" target-dir="x86" arch="x86" custom="true" implementation="src/windows/libs/x86/SQLite3.UWP.dll"/>
-        <framework src="src/windows/libs/x86/BarcodeComponent.winmd" target-dir="x64" arch="x64" custom="true"/>
+        <framework src="src/windows/libs/dummy/BarcodeComponent.winmd" target-dir="x64" arch="x64" custom="true"/>
         <framework src="src/windows/libs/x86/SQLite3.winmd" target-dir="x64" arch="x64" custom="true" implementation="src/windows/libs/x64/SQLite3.UWP.dll"/>
     </platform>
 

package/spec/package.json

@@ -1,4 +1,11 @@
 {
   "name": "cordova-sqlite-spec",
-  "cordova": {}
+  "cordova": {
+    "plugins": {
+      "cordova-plugin-file": {}
+    }
+  },
+  "devDependencies": {
+    "cordova-plugin-file": "^6.0.2"
+  }
 }

package/spec/www/index.html

@@ -39,6 +39,7 @@
   <script src="spec/ext-tx-blob-test.js"></script>
   <script src="spec/base64-encode-test.js"></script>
   <script src="spec/blobfrombase64-test.js"></script>
+  <script src="spec/android-db-location-test.js"></script>
   <!--
   <script src="spec/big-memory-test.js"></script>
   - -->

package/spec/www/spec/android-db-location-test.js

@@ -0,0 +1,327 @@
+/* 'use strict'; */
+
+var MYTIMEOUT = 20000;
+
+var isWindows = /Windows /.test(navigator.userAgent); // Windows
+var isAndroid = !isWindows && /Android/.test(navigator.userAgent);
+
+var pluginScenarioList = [
+  isAndroid ? 'Plugin-implementation-default' : 'Plugin',
+  'Plugin-implementation-2'
+];
+
+//var pluginScenarioCount = isAndroid ? 2 : 1;
+var pluginScenarioCount = 1;
+
+var mytests = function() {
+
+  for (var i=0; i<pluginScenarioCount; ++i) {
+
+    describe(pluginScenarioList[i] + ': Android db directory test(s)', function() {
+      var scenarioName = pluginScenarioList[i];
+      var suiteName = scenarioName + ': ';
+      // FUTURE TBD
+      //var isImpl2 = (i === 1);
+
+        it(suiteName + 'Create db file in Documents, check size, copy to default location, check copy, and delete original', function(done) {
+          if (!isAndroid) pending('SKIP for iOS/Windows/WP8');
+
+          var dbname = 'Create-db-in-documents-test.db';
+          var copyname = 'copy-db-from-documents.db';
+
+          window.resolveLocalFileSystemURL(cordova.file.dataDirectory, function(dataDirectoryEntry) {
+            expect(dataDirectoryEntry).toBeDefined();
+
+            expect(dataDirectoryEntry.isDirectory).toBe(true);
+
+            dataDirectoryEntry.getDirectory('Documents', null, function(documentsDirectoryEntry) {
+              expect(documentsDirectoryEntry).toBeDefined();
+              expect(documentsDirectoryEntry.isDirectory).toBe(true);
+
+              var createDatabaseDirectoryEntry = documentsDirectoryEntry;
+              var db = window.sqlitePlugin.openDatabase({name: dbname, androidDatabaseLocation: createDatabaseDirectoryEntry.toURL()});
+
+              db.transaction(function(tx) {
+                tx.executeSql('DROP TABLE IF EXISTS tt');
+                tx.executeSql('CREATE TABLE tt (data)');
+                tx.executeSql('INSERT INTO tt VALUES (?)', ['test-value']);
+
+              }, function(error) {
+                // NOT EXPECTED:
+                expect(false).toBe(true);
+                expect(JSON.stringify(error)).toBe('---');
+                // Close (PLUGIN) & finish:
+                db.close(done, done);
+
+              }, function() {
+                db.close(function() {
+                  createDatabaseDirectoryEntry.getFile(dbname, null, function(dbFileEntry) {
+                    expect(dbFileEntry).toBeDefined();
+                    expect(dbFileEntry.isFile).toBe(true);
+
+                    dbFileEntry.file(function(f) {
+                      expect(f).toBeDefined();
+                      expect(f.size).toBeDefined();
+                      expect(f.size).not.toBe(-1);
+                      expect(f.size).not.toBe(0);
+                      expect(f.size > 1000).toBe(true);
+
+                      window.resolveLocalFileSystemURL(cordova.file.applicationStorageDirectory, function(storageDirectoryEntry) {
+                        expect(storageDirectoryEntry).toBeDefined();
+                        expect(storageDirectoryEntry.isDirectory).toBe(true);
+
+                        storageDirectoryEntry.getDirectory('databases', null, function(dbDirectoryEntry) {
+                          expect(dbDirectoryEntry).toBeDefined();
+
+                          dbFileEntry.copyTo(dbDirectoryEntry, copyname, function(newFileEntry) {
+                            expect(newFileEntry).toBeDefined();
+                            expect(newFileEntry.isFile).toBe(true);
+
+                            var db2 = window.sqlitePlugin.openDatabase({name: copyname, location: 'default'});
+
+                            db2.transaction(function(tx) {
+                              tx.executeSql('SELECT * FROM tt', [], function(tx_ignored, rs) {
+                                expect(rs).toBeDefined();
+                                expect(rs.rows).toBeDefined();
+                                expect(rs.rows.length).toBe(1);
+                                expect(rs.rows.item(0).data).toBeDefined();
+                                expect(rs.rows.item(0).data).toBe('test-value');
+
+                                var deleteOptions = {name: dbname, androidDatabaseLocation: createDatabaseDirectoryEntry.toURL()};
+                                window.sqlitePlugin.deleteDatabase(deleteOptions, function() {
+                                  createDatabaseDirectoryEntry.getFile(dbname, null, function(dbFileEntry) {
+                                    // NOT EXPECTED - old database file is still available:
+                                    expect(false).toBe(true);
+                                    done();
+                                  }, function(error) {
+                                    // EXPECTED RESULT - old database file is gone:
+                                    expect(true).toBe(true);
+                                    done();
+                                  });
+
+                                }, function(error) {
+                                  // NOT EXPECTED:
+                                  expect(false).toBe(true);
+                                  expect(JSON.stringify(error)).toBe('---');
+                                  done();
+                                });
+
+                              });
+                            }, function(error) {
+                              // NOT EXPECTED:
+                              expect(false).toBe(true);
+                              expect(JSON.stringify(error)).toBe('---');
+                              // Close (PLUGIN) & finish:
+                              db.close(done, done);
+                            });
+
+                          }, function(error) {
+                            // NOT EXPECTED:
+                            expect(false).toBe(true);
+                            expect(JSON.stringify(error)).toBe('---');
+                            done();
+                          });
+
+                        }, function(error) {
+                          // NOT EXPECTED:
+                          expect(false).toBe(true);
+                          expect(JSON.stringify(error)).toBe('---');
+                          done();
+                        });
+
+                      }, function(error) {
+                        // NOT EXPECTED:
+                        expect(false).toBe(true);
+                        expect(JSON.stringify(error)).toBe('---');
+                        done();
+                      });
+
+                    }, function(error) {
+                      // NOT EXPECTED:
+                      expect(false).toBe(true);
+                      expect(JSON.stringify(error)).toBe('---');
+                      done();
+                    });
+
+                  }, function(error) {
+                    // NOT EXPECTED:
+                    expect(false).toBe(true);
+                    expect(JSON.stringify(error)).toBe('---');
+                    done();
+                  });
+
+                }, function(error) {
+                  // NOT EXPECTED:
+                  expect(false).toBe(true);
+                  expect(JSON.stringify(error)).toBe('---');
+                  done();
+                });
+              });
+
+            }, function(error) {
+              // NOT EXPECTED:
+              expect(false).toBe(true);
+              expect(JSON.stringify(error)).toBe('---');
+              done();
+            });
+
+          }, function(error) {
+            // NOT EXPECTED:
+            expect(false).toBe(true);
+            expect(JSON.stringify(error)).toBe('---');
+            done();
+          });
+
+        }, MYTIMEOUT);
+
+        it(suiteName + 'Create db file in external files directory, check size, copy to default location, check copy, and delete original', function(done) {
+          if (!isAndroid) pending('SKIP for iOS/Windows/WP8');
+
+          var dbname = 'Create-db-in-external-files-test.db';
+          var copyname = 'copy-db-from-external-files.db';
+
+          window.resolveLocalFileSystemURL(cordova.file.externalDataDirectory, function(externalDataDirectoryEntry) {
+            expect(externalDataDirectoryEntry).toBeDefined();
+
+            expect(externalDataDirectoryEntry.isDirectory).toBe(true);
+
+              var createDatabaseDirectoryEntry = externalDataDirectoryEntry;
+              var db = window.sqlitePlugin.openDatabase({name: dbname, androidDatabaseLocation: createDatabaseDirectoryEntry.toURL()});
+
+              db.transaction(function(tx) {
+                tx.executeSql('DROP TABLE IF EXISTS tt');
+                tx.executeSql('CREATE TABLE tt (data)');
+                tx.executeSql('INSERT INTO tt VALUES (?)', ['test-value']);
+
+              }, function(error) {
+                // NOT EXPECTED:
+                expect(false).toBe(true);
+                expect(JSON.stringify(error)).toBe('---');
+                // Close (PLUGIN) & finish:
+                db.close(done, done);
+
+              }, function() {
+                db.close(function() {
+                  createDatabaseDirectoryEntry.getFile(dbname, null, function(dbFileEntry) {
+                    expect(dbFileEntry).toBeDefined();
+                    expect(dbFileEntry.isFile).toBe(true);
+
+                    dbFileEntry.file(function(f) {
+                      expect(f).toBeDefined();
+                      expect(f.size).toBeDefined();
+                      expect(f.size).not.toBe(-1);
+                      expect(f.size).not.toBe(0);
+                      expect(f.size > 1000).toBe(true);
+
+                      window.resolveLocalFileSystemURL(cordova.file.applicationStorageDirectory, function(storageDirectoryEntry) {
+                        expect(storageDirectoryEntry).toBeDefined();
+                        expect(storageDirectoryEntry.isDirectory).toBe(true);
+
+                        storageDirectoryEntry.getDirectory('databases', null, function(dbDirectoryEntry) {
+                          expect(dbDirectoryEntry).toBeDefined();
+
+                          dbFileEntry.copyTo(dbDirectoryEntry, copyname, function(newFileEntry) {
+                            expect(newFileEntry).toBeDefined();
+                            expect(newFileEntry.isFile).toBe(true);
+
+                            var db2 = window.sqlitePlugin.openDatabase({name: copyname, location: 'default'});
+
+                            db2.transaction(function(tx) {
+                              tx.executeSql('SELECT * FROM tt', [], function(tx_ignored, rs) {
+                                expect(rs).toBeDefined();
+                                expect(rs.rows).toBeDefined();
+                                expect(rs.rows.length).toBe(1);
+                                expect(rs.rows.item(0).data).toBeDefined();
+                                expect(rs.rows.item(0).data).toBe('test-value');
+
+                                var deleteOptions = {name: dbname, androidDatabaseLocation: createDatabaseDirectoryEntry.toURL()};
+                                window.sqlitePlugin.deleteDatabase(deleteOptions, function() {
+                                  createDatabaseDirectoryEntry.getFile(dbname, null, function(dbFileEntry) {
+                                    // NOT EXPECTED - old database file is still available:
+                                    expect(false).toBe(true);
+                                    done();
+                                  }, function(error) {
+                                    // EXPECTED RESULT - old database file is gone:
+                                    expect(true).toBe(true);
+                                    done();
+                                  });
+
+                                }, function(error) {
+                                  // NOT EXPECTED:
+                                  expect(false).toBe(true);
+                                  expect(JSON.stringify(error)).toBe('---');
+                                  done();
+                                });
+
+                              });
+                            }, function(error) {
+                              // NOT EXPECTED:
+                              expect(false).toBe(true);
+                              expect(JSON.stringify(error)).toBe('---');
+                              // Close (PLUGIN) & finish:
+                              db.close(done, done);
+                            });
+
+                          }, function(error) {
+                            // NOT EXPECTED:
+                            expect(false).toBe(true);
+                            expect(JSON.stringify(error)).toBe('---');
+                            done();
+                          });
+
+                        }, function(error) {
+                          // NOT EXPECTED:
+                          expect(false).toBe(true);
+                          expect(JSON.stringify(error)).toBe('---');
+                          done();
+                        });
+
+                      }, function(error) {
+                        // NOT EXPECTED:
+                        expect(false).toBe(true);
+                        expect(JSON.stringify(error)).toBe('---');
+                        done();
+                      });
+
+                    }, function(error) {
+                      // NOT EXPECTED:
+                      expect(false).toBe(true);
+                      expect(JSON.stringify(error)).toBe('---');
+                      done();
+                    });
+
+                  }, function(error) {
+                    // NOT EXPECTED:
+                    expect(false).toBe(true);
+                    expect(JSON.stringify(error)).toBe('---');
+                    done();
+                  });
+
+                }, function(error) {
+                  // NOT EXPECTED:
+                  expect(false).toBe(true);
+                  expect(JSON.stringify(error)).toBe('---');
+                  done();
+                });
+              });
+
+          }, function(error) {
+            // NOT EXPECTED:
+            expect(false).toBe(true);
+            expect(JSON.stringify(error)).toBe('---');
+            done();
+          });
+
+
+        }, MYTIMEOUT);
+
+    });
+
+  }
+
+}
+
+if (window.hasBrowser) mytests();
+else exports.defineAutoTests = mytests;
+
+/* vim: set expandtab : */

package/spec/www/spec/db-tx-sql-features-test.js

@@ -362,6 +362,27 @@ var mytests = function() {
           });
         }, MYTIMEOUT);
 
+        it(suiteName + 'Math functions test', function(done) {
+          if (isWebSql) pending('SKIP for (WebKit) Web SQL');
+          if (isAndroid && isImpl2) pending('XXX XXX android.database'); // XXX
+          if (isMac) pending('NOT SUPPORTED for macOS');
+
+          var db = openDatabase('math-functions-test.db');
+          expect(db).toBeDefined();
+
+          db.transaction(function(tx) {
+            tx.executeSql("SELECT COS(PI()) AS my_value;", null, function(tx, res) {
+              expect(res.rows.item(0).my_value).toEqual(-1);
+              // Close (plugin only) & finish:
+              db.close(done, done);
+            }, function(tx, e) {
+              // NOT EXPECTED (went wrong):
+              expect(JSON.stringify(e)).toBe('--');
+              done.fail();
+            });
+          });
+        }, MYTIMEOUT);
+
     });
 
   }