X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=tests.js;h=9abe573a0c1222478d16f35b13ac8caad0c3ebca;hb=2a6dd137d91007a14fb841f24d1eabccd3f4f4b5;hp=37a758f4f1e8626a11bcbf9301f88ef06ca01915;hpb=3599674db4855614d9123f2f80dcf0a37c34eb79;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git

diff --git a/tests.js b/tests.js
index 37a758f..9abe573 100644
--- a/tests.js
+++ b/tests.js
@@ -80,7 +80,7 @@ function waitForEntropyFeedback(fn, maxTime) {
         maxTime = testMaxTime;
     }
     var origFeedback = page.evaluate(function() {
-        return $(".entropy-feedback").text();
+        return $(".entropy-container").text();
     });
     var start = new Date().getTime();
     var wait = function keepWaiting() {
@@ -92,7 +92,7 @@ function waitForEntropyFeedback(fn, maxTime) {
             return;
         }
         var feedback = page.evaluate(function() {
-            return $(".entropy-feedback").text();
+            return $(".entropy-container").text();
         });
         var hasFinished = feedback != origFeedback;
         if (hasFinished) {
@@ -2304,6 +2304,7 @@ page.open(url, function(status) {
         "dice",
         "base 10",
         "hexadecimal",
+        "cards",
     ];
     for (var i=0; i<options.length; i++) {
         var option = options[i];
@@ -2518,7 +2519,7 @@ page.open(url, function(status) {
         // check the number of bits of entropy is shown
         waitForEntropyFeedback(function() {
             var entropyText = page.evaluate(function() {
-                return $(".entropy-feedback").text();
+                return $(".entropy-container").text();
             });
             if (entropyText.replace(/\s/g,"").indexOf("Bits" + expected) == -1) {
                 console.log("Accumulated entropy is not shown correctly for " + entropy);
@@ -2537,76 +2538,151 @@ page.open(url, function(status) {
 });
 },
 
-// The next strength above 0-word mnemonics is considered extremely weak
-// The next strength above 3-word mnemonics is considered very weak
-// The next strength above 6-word mnemonics is considered weak
-// The next strength above 9-word mnemonics is considered strong
-// The next strength above 12-word mnemonics is considered very strong
-// The next strength above 15-word mnemonics is considered extremely strong
+// There is feedback provided about the supplied entropy
 function() {
 page.open(url, function(status) {
     var tests = [
         {
             entropy: "A",
+            filtered: "A",
+            type: "hexadecimal",
+            events: 1,
+            bits: 4,
             words: 0,
             strength: "extremely weak",
         },
         {
             entropy: "AAAAAAAA",
+            filtered: "AAAAAAAA",
+            type: "hexadecimal",
+            events: 8,
+            bits: 32,
             words: 3,
             strength: "extremely weak",
         },
         {
             entropy: "AAAAAAAA B",
+            filtered: "AAAAAAAAB",
+            type: "hexadecimal",
+            events: 9,
+            bits: 36,
             words: 3,
             strength: "extremely weak",
         },
         {
             entropy: "AAAAAAAA BBBBBBBB",
+            filtered: "AAAAAAAABBBBBBBB",
+            type: "hexadecimal",
+            events: 16,
+            bits: 64,
             words: 6,
             strength: "very weak",
         },
         {
             entropy: "AAAAAAAA BBBBBBBB CCCCCCCC",
+            filtered: "AAAAAAAABBBBBBBBCCCCCCCC",
+            type: "hexadecimal",
+            events: 24,
+            bits: 96,
             words: 9,
             strength: "weak",
         },
         {
             entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD",
+            filtered: "AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD",
+            type: "hexadecimal",
+            events: 32,
+            bits: 128,
+            words: 12,
+            strength: "easily cracked",
+        },
+        {
+            entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDA",
+            filtered: "AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDA",
+            type: "hexadecimal",
+            events: 32,
+            bits: 128,
             words: 12,
             strength: "strong",
         },
         {
-            entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE",
+            entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDA EEEEEEEE",
+            filtered: "AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDAEEEEEEEE",
+            type: "hexadecimal",
+            events: 40,
+            bits: 160,
             words: 15,
             strength: "very strong",
         },
         {
-            entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE FFFFFFFF",
+            entropy: "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDA EEEEEEEE FFFFFFFF",
+            filtered: "AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDAEEEEEEEEFFFFFFFF",
+            type: "hexadecimal",
+            events: 48,
+            bits: 192,
             words: 18,
             strength: "extremely strong",
-        }
+        },
     ];
     // use entropy
     page.evaluate(function() {
         $(".use-entropy").prop("checked", true).trigger("change");
     });
     var nextTest = function runNextTest(i) {
+        function getFeedbackError(expected, actual) {
+            if (actual.indexOf(expected.filtered) == -1) {
+                return "Filtered value not in feedback";
+            }
+            if (actual.indexOf(expected.type) == -1) {
+                return "Entropy type not in feedback";
+            }
+            if (actual.indexOf(expected.events) == -1) {
+                return "Event count not in feedback";
+            }
+            if (actual.indexOf(expected.bits) == -1) {
+                return "Bit count not in feedback";
+            }
+            if (actual.indexOf(expected.strength) == -1) {
+                return "Strength not in feedback";
+            }
+            return false;
+        }
         test = tests[i];
         page.evaluate(function(e) {
             $(".addresses").empty();
             $(".phrase").val("");
             $(".entropy").val(e).trigger("input");
         }, test.entropy);
-        if (test.words == 0) {
+        waitForEntropyFeedback(function() {
             var mnemonic = page.evaluate(function() {
                 return $(".phrase").val();
             });
-            if (mnemonic.length > 0) {
-                console.log("Mnemonic length for " + test.strength + " strength is not " + test.words);
-                console.log("Mnemonic: " + mnemonic);
+            // Check mnemonic length
+            if (test.words == 0) {
+                if (mnemonic.length > 0) {
+                    console.log("Mnemonic length for " + test.strength + " strength is not " + test.words);
+                    console.log("Mnemonic: " + mnemonic);
+                    fail();
+                }
+            }
+            else {
+                if (mnemonic.split(" ").length != test.words) {
+                    console.log("Mnemonic length for " + test.strength + " strength is not " + test.words);
+                    console.log("Mnemonic: " + mnemonic);
+                    fail();
+                }
+            }
+            // check feedback
+            var feedback = page.evaluate(function() {
+                return $(".entropy-container").text();
+            });
+            var feedbackError = getFeedbackError(test, feedback);
+            if (feedbackError) {
+                console.log("Entropy feedback for " + test.entropy + " returned error");
+                console.log(feedbackError);
                 fail();
             }
+            // Run next test
             var isLastTest = i == tests.length - 1;
             if (isLastTest) {
                 next();
@@ -2614,49 +2690,21 @@ page.open(url, function(status) {
             else {
                 runNextTest(i+1);
             }
-        }
-        else {
-            waitForGenerate(function() {
-                // check the number of words in the current mnemonic
-                var mnemonic = page.evaluate(function() {
-                    return $(".phrase").val();
-                });
-                if (mnemonic.split(" ").length != test.words) {
-                    console.log("Mnemonic length for " + test.strength + " strength is not " + test.words);
-                    console.log("Mnemonic: " + mnemonic);
-                    fail();
-                }
-                // check the strength of the mnemonic is shown
-                var entropyText = page.evaluate(function() {
-                    return $(".entropy-container").text();
-                });
-                if (entropyText.indexOf(test.strength) == -1) {
-                    console.log("Strength indicator for " + test.strength + " mnemonic is incorrect");
-                    fail();
-                }
-                var isLastTest = i == tests.length - 1;
-                if (isLastTest) {
-                    next();
-                }
-                else {
-                    runNextTest(i+1);
-                }
-            });
-        }
+        });
     }
     nextTest(0);
 });
 },
 
-// Entropy is truncated from the right
+// Entropy is truncated from the left
 function() {
 page.open(url, function(status) {
-    var expected = "abandon abandon ability";
+    var expected = "avocado zoo zone";
     // use entropy
     page.evaluate(function() {
         $(".use-entropy").prop("checked", true).trigger("change");
         var entropy  = "00000000 00000000 00000000 00000000";
-            entropy += "11111111 11111111 11111111 1111"; // Missing last byte, only first 8 bytes are used
+            entropy += "11111111 11111111 11111111 1111"; // Missing last byte
         $(".entropy").val(entropy).trigger("input");
     });
     // check the entropy is truncated from the right
@@ -2707,8 +2755,6 @@ page.open(url, function(status) {
 // https://bip32jp.github.io/english/index.html
 // NOTES:
 // Is incompatible with:
-//     base 6 with leading zeros
-//     base 6 wth 12 words / 53 chars
 //     base 20
 function() {
 page.open(url, function(status) {