tests/string-lerp.js

   1 var JS = this.JS || require('jstest');
   2 var m = require('../string-lerp');
   3
   4 var HALF_POOS = /\uD83D\uD83D|\uDCA9\uDCA9|\uD83D$/;
   5 var UNUSUAL_Q = 'q\u0307\u0323';
   6
   7 JS.Test.describe('fast lerp', function () { with (this) {
   8     var lerp = m.fastLerp;
   9     var A = "Do you like green eggs and ham?";
  10     var B = "I do not like them, Sam-I-am.";
  11
  12     it("handles empty strings", function () { with (this) {
  13         assertEqual("", lerp("", "", -1));
  14         assertEqual("", lerp("", "", 0));
  15         assertEqual("", lerp("", "", 0.5));
  16         assertEqual("", lerp("", "", 1));
  17         assertEqual("", lerp("", "", 2));
  18     }});
  19
  20     it("maintains identity", function () { with (this) {
  21         for (var i = -1; i < 2; i += 1/1024) {
  22             assertEqual(A, lerp(A, A, i));
  23             assertEqual(B, lerp(B, B, i));
  24         }
  25     }});
  26
  27     it("handles lows", function () { with (this) {
  28         assertEqual(A, lerp(A, B, -Infinity));
  29         assertEqual(A, lerp(A, B, -1));
  30         assertEqual(A, lerp(A, B, 0));
  31     }});
  32
  33     it("handles highs", function () { with (this) {
  34         assertEqual(B, lerp(A, B, 1));
  35         assertEqual(B, lerp(A, B, 2));
  36         assertEqual(B, lerp(A, B, Infinity));
  37     }});
  38
  39     it("crams strings together", function () { with (this) {
  40         assertEqual("I do not ke green eggs and ham?", lerp(A, B, 0.3));
  41         assertEqual("I do not like tn eggs and ham?", lerp(A, B, 0.5));
  42         assertEqual("I do not like them, Sam-I-am?", lerp(A, B, 0.98));
  43     }});
  44
  45     it("doesn't make half a poo", function () { with (this) {
  46         var poos = "\uD83D\uDCA9\uD83D\uDCA9\uD83D\uDCA9\uD83D\uDCA9";
  47         assertEqual("\uD83D\uDCA9\uD83D\uDCA9", lerp("", poos, 0.5));
  48         assertEqual("\uD83D\uDCA9", lerp("", poos, 0.35));
  49
  50         for (var i = 0; i <= 1; i += 1/256)
  51             assertNot(lerp("", poos, i).match(HALF_POOS));
  52     }});
  53
  54     it("doesn't misplace combining marks", function () { with (this) {
  55         for (var i = 0; i <= 1; i += 1/256) {
  56             var r = lerp("a", UNUSUAL_Q, i);
  57             assert(r === "a" || r === UNUSUAL_Q);
  58         }
  59     }});
  60 }});
  61
  62 JS.Test.describe('diff lerp', function () { with (this) {
  63     var lerp = m.diffLerp;
  64     var A = "Do you like green eggs and ham?";
  65     var B = "I do not like them, Sam-I-am.";
  66
  67     it("handles empty strings", function () { with (this) {
  68         assertEqual("", lerp("", "", -1));
  69         assertEqual("", lerp("", "", 0));
  70         assertEqual("", lerp("", "", 0.5));
  71         assertEqual("", lerp("", "", 1));
  72         assertEqual("", lerp("", "", 2));
  73     }});
  74
  75     it("maintains identity", function () { with (this) {
  76         for (var i = -1; i < 2; i += 1/1024) {
  77             assertEqual(A, lerp(A, A, i));
  78             assertEqual(B, lerp(B, B, i));
  79         }
  80     }});
  81
  82     it("handles lows", function () { with (this) {
  83         assertEqual(A, lerp(A, B, -Infinity));
  84         assertEqual(A, lerp(A, B, -1));
  85         assertEqual(A, lerp(A, B, 0));
  86     }});
  87
  88     it("handles highs", function () { with (this) {
  89         assertEqual(B, lerp(A, B, 1));
  90         assertEqual(B, lerp(A, B, 2));
  91         assertEqual(B, lerp(A, B, Infinity));
  92     }});
  93
  94     it("edits strings", function () { with (this) {
  95         assertEqual(A, lerp(A, B, 0.01));
  96         assertEqual("I do not like treen eggs and ham?", lerp(A, B, 0.3));
  97         assertEqual("I do not like them, eggs and ham?", lerp(A, B, 0.5));
  98         assertEqual("I do not like them, Sam-Iham?", lerp(A, B, 0.9));
  99         assertEqual(B, lerp(A, B, 0.99));
 100     }});
 101
 102     it("doesn't make half a poo", function () { with (this) {
 103         var poos = "\uD83D\uDCA9\uD83D\uDCA9\uD83D\uDCA9\uD83D\uDCA9";
 104         assertEqual("\uD83D\uDCA9\uD83D\uDCA9", lerp("", poos, 0.5));
 105         assertEqual("\uD83D\uDCA9", lerp("", poos, 0.35));
 106
 107         for (var i = 0; i <= 1; i += 1/256)
 108             assertNot(lerp("", poos, i).match(HALF_POOS));
 109     }});
 110
 111     it("doesn't misplace combining marks", function () { with (this) {
 112         for (var i = 0; i <= 1; i += 1/256) {
 113             var r = lerp("a", UNUSUAL_Q, i);
 114             assert(r === "a" || r === UNUSUAL_Q);
 115         }
 116     }});
 117
 118     it("prefers ins/del to sub/sub", function () { with (this) {
 119         // When the cost is uniform this string can be transformed by
 120         // rewriting the whole thing for the same cost as deleting the
 121         // front and adding to the back. But visually, we'd rather do
 122         // the latter.
 123         assertEqual("core", lerp("hard core", "core dump", 0.50));
 124     }});
 125
 126     it("weights ins/del cheaper than sub", function () { with (this) {
 127         // When the cost is uniform it is cheaper to rewrite the
 128         // former into the latter. But we'd rather keep the "core" for
 129         // visual reasons, so we need to make sure we have unequal
 130         // costs.
 131         assertEqual("core", lerp("apple core", "core dump", 0.51));
 132     }});
 133 }});
 134
 135 JS.Test.describe('numeric lerp', function () { with (this) {
 136     var lerp = m.numericLerp;
 137
 138     it("handles empty strings", function () { with (this) {
 139         assertEqual("", lerp("", "", -1));
 140         assertEqual("", lerp("", "", 0));
 141         assertEqual("", lerp("", "", 0.5));
 142         assertEqual("", lerp("", "", 1));
 143         assertEqual("", lerp("", "", 2));
 144     }});
 145
 146     it("handles single numbers", function () { with (this) {
 147         assertEqual("0", lerp("0", "100", 0));
 148         assertEqual("50", lerp("0", "100", 0.5));
 149         assertEqual("100", lerp("0", "100", 1.0));
 150         assertEqual("150", lerp("0", "100", 1.5));
 151     }});
 152
 153     it("rounds integers", function () { with (this) {
 154         assertEqual("12", lerp("0", "100", 0.123));
 155         assertEqual("12.3", lerp("0", "100.0", 0.123));
 156         assertEqual("12.3", lerp("0.0", "100", 0.123));
 157         assertEqual("12.3", lerp("0.0", "100.0", 0.123));
 158     }});
 159
 160     it("thinks about precision", function () { with (this) {
 161         assertEqual("12.30", lerp("0", "100.00", 0.123));
 162         assertEqual("12.30", lerp("0.00", "100", 0.123));
 163         assertEqual("12.300", lerp("0.000", "100.000", 0.123));
 164     }});
 165
 166     it("computes parameters outside [0, 1]", function () { with (this) {
 167         assertEqual("Giving 110%", lerp("Giving 0%", "Giving 100%", 1.1));
 168     }});
 169
 170     it("handles multiple numbers", function () { with (this) {
 171         var A = "Chapter 0. The sky was rgb(0, 0, 0)."
 172         var B = "Chapter 10. The sky was rgb(0, 0, 255)."
 173         assertEqual(A, lerp(A, B, 0));
 174         assertEqual(B, lerp(A, B, 1));
 175         assertEqual("Chapter 5. The sky was rgb(0, 0, 128).", lerp(A, B, 0.5));
 176     }});
 177 }});
 178
 179 JS.Test.describe('fast lerp', function () { with (this) {
 180     var lerp = m.lerp;
 181     var A = "Do you like green eggs and ham?";
 182     var B = "I do not like them, Sam-I-am.";
 183
 184     it("handles empty strings", function () { with (this) {
 185         assertEqual("", lerp("", "", -1));
 186         assertEqual("", lerp("", "", 0));
 187         assertEqual("", lerp("", "", 0.5));
 188         assertEqual("", lerp("", "", 1));
 189         assertEqual("", lerp("", "", 2));
 190     }});
 191
 192     it("maintains identity", function () { with (this) {
 193         for (var i = -1; i < 2; i += 1/1024) {
 194             assertEqual(A, lerp(A, A, i));
 195             assertEqual(B, lerp(B, B, i));
 196         }
 197     }});
 198
 199     it("handles lows", function () { with (this) {
 200         assertEqual(A, lerp(A, B, -Infinity));
 201         assertEqual(A, lerp(A, B, -1));
 202         assertEqual(A, lerp(A, B, 0));
 203     }});
 204
 205     it("handles highs", function () { with (this) {
 206         assertEqual(B, lerp(A, B, 1));
 207         assertEqual(B, lerp(A, B, 2));
 208         assertEqual(B, lerp(A, B, Infinity));
 209     }});
 210 }});