js: Testing lare messages

--

* Some assumption on messages were wrong. Now the tests use more
  reasonable sizes.
* bigString now uses the full utf8-extent, with the exception of
  U+0000. This code gets dropped during the encryption-decryption
  process.

lang/js/BrowserTestExtension/tests/encryptTest.js

@@ -36,7 +36,7 @@ describe('Encryption', function () {
 
     it('Successful encrypt 5 MB', function (done) {
         let prm = Gpgmejs.init();
-        let data = bigString(5);
+        let data = fixedLengthString(5);
         prm.then(function (context) {
             context.encrypt(
                 data,
@@ -51,10 +51,9 @@ describe('Encryption', function () {
         });
     }).timeout(10000);
 
-/**
     it('Successful encrypt 20 MB', function (done) {
         let prm = Gpgmejs.init();
-        let data = bigString(20);
+        let data = fixedLengthString(20);
         prm.then(function (context) {
             context.encrypt(
                 data,
@@ -68,12 +67,10 @@ describe('Encryption', function () {
                 });
         });
     }).timeout(20000);
-*/
+
-/**
+    it('Successful encrypt 50 MB', function (done) {
-    it('Successful encrypt 30 MB', function (done) {
-        // TODO: There seems to be a limit imposed at least by chrome at about 21 MB
         let prm = Gpgmejs.init();
-        let data = bigString(30);
+        let data = fixedLengthString(50);
         prm.then(function (context) {
             context.encrypt(
                 data,
@@ -87,7 +84,6 @@ describe('Encryption', function () {
                 });
         });
     }).timeout(20000);
-*/
 
     it('Sending encryption without keys fails', function (done) {
         let prm = Gpgmejs.init();
@@ -120,7 +116,6 @@ describe('Encryption', function () {
         });
     });
 
-
     it('Sending encryption with non existing keys fails', function (done) {
         let prm = Gpgmejs.init();
         prm.then(function (context) {
@@ -138,21 +133,24 @@ describe('Encryption', function () {
         });
     }).timeout(5000);;
 
-    it('Overly large message ( >= 48MB) is rejected', function (done) {
+    it('Overly large message ( > 65MB) is rejected', function (done) {
         let prm = Gpgmejs.init();
         prm.then(function (context) {
             context.encrypt(
-                bigString(48),
+                fixedLengthString(65),
                 inputvalues.encrypt.good.fingerprint).then(function (answer) {
                     expect(answer).to.be.undefined;
                 }, function(error){
                     expect(error).to.be.an.instanceof(Error);
-                    // TODO who is throwing the error here?
+                    // expect(error.code).to.equal('GNUPG_ERROR');
-                    // It is not a GPGME_Error!
+                    // TODO: there is a 64 MB hard limit at least in chrome at:
+                    // chromium//extensions/renderer/messaging_util.cc:
+                    // kMaxMessageLength
                     context.connection.disconnect();
                     done();
                 });
         });
     }).timeout(8000);
+
     // TODO check different valid parameter
 });

lang/js/BrowserTestExtension/tests/inputvalues.js

@@ -59,14 +59,27 @@ var inputvalues = {
     }
 };
 
-// (Pseudo-)Random String from a Uint8Array, given approx. size in Megabytes
+// (Pseudo-)Random String covering all of utf8.
-function bigString(megabytes){
+function bigString(length){
-    let maxlength = 1024 * 1024 * megabytes;
+    var uint = '';
+    let arr = [];
+    for (let i= 0; i < length; i++){
+        arr.push(String.fromCharCode(
+            Math.floor(Math.random() * 10174) + 1)
+        );
+    }
+    return arr.join('');
+}
+
+function fixedLengthString(megabytes){
+    let maxlength = 1024 * 1024 * megabytes / 2;
     let uint = new Uint8Array(maxlength);
     for (let i = 0; i < maxlength; i++){
-        uint[i] = Math.random() * Math.floor(256);
+        uint[i] = Math.floor(Math.random()* 256);
     }
-    return new TextDecoder('utf-8').decode(uint);
+    let td = new TextDecoder('ascii');
+    let result = td.decode(uint);
+    return result;
 }
 
 // (Pseudo-)Random Uint8Array, given size in Megabytes
@@ -82,19 +95,19 @@ function bigUint8(megabytes){
 // (Pseudo-)Random string with very limited charset (ascii only, no control chars)
 function bigBoringString(megabytes){
     let maxlength = 1024 * 1024 * megabytes;
-    let string = '';
+    let string = [];
     let chars = ' 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
     for (let i= 0; i < maxlength; i++){
-        string = string + chars[Math.floor(Math.random() * chars.length)];
+        string.push(chars[Math.floor(Math.random() * chars.length)]);
     }
-    return string;
+    return string.join('');
 }
 
 // Some String with simple chars, with different characteristics, but still
 // expected to occur in an averag message
 function slightlyLessBoringString(megabytes, set){
     let maxlength = 1024 * 1024 * megabytes;
-    let string = '';
+    let string = [];
     let chars = '';
     if (set ===1 ) {
         chars = '\n\"\r \'';
@@ -108,9 +121,9 @@ function slightlyLessBoringString(megabytes, set){
         chars = '*<>\n\"\r§$%&/()=?`#+-{}[] \'';
     }
     for (let i= 0; i < maxlength; i++){
-        string = string + chars[Math.floor(Math.random() * chars.length)];
+        string.push(chars[Math.floor(Math.random() * chars.length)]);
     }
-    return string;
+    return string.join('');
 }
 
 // Data encrypted with testKey

lang/js/BrowserTestExtension/tests/longRunningTests.js

@@ -2,7 +2,7 @@ describe('Long running Encryption/Decryption', function () {
     for (let i=0; i < 100; i++) {
         it('Successful encrypt/decrypt completely random data ' + (i+1) + '/100', function (done) {
             let prm = Gpgmejs.init();
-            let data = bigString(2);
+            let data = bigString(2*1024*1024);
                 prm.then(function (context) {
                     context.encrypt(data,
                         inputvalues.encrypt.good.fingerprint).then(
@@ -17,13 +17,24 @@ describe('Long running Encryption/Decryption', function () {
                                     function(result){
                                         expect(result).to.not.be.empty;
                                         expect(result.data).to.be.a('string');
+                                        if (result.data.length !== data.length) {
+                                            console.log('diff: ' + (result.data.length - data.length));
+                                            for (let i=0; i < result.data.length; i++){
+                                                if (result.data[i] !== data[i]){
+                                                    console.log('position: ' + i);
+                                                    console.log('result : '+ result.data.charCodeAt(i) + result.data[i-2] + result.data[i-1] + result.data[i] + result.data[i+1] + result.data[i+2]);
+                                                    console.log('original: ' + data.charCodeAt(i) + data[i-2] + data[i-1] + data[i] + data[i+1] + data[i+2]);
+                                                    break;
+                                                }
+                                            }
+                                        }
                                         expect(result.data).to.equal(data);
                                         context.connection.disconnect();
                                         done();
                                 });
                         });
                 });
-        }).timeout(5000);
+        }).timeout(8000);
     };
 
     it('Successful encrypt 1 MB Uint8Array', function (done) {